Many interesting questions about the software quality of a code base can only be answered adequately if fine-grained information about the evolution of quality metrics over time and the contributions of individual developers is known. We present an approach for tracking static analysis violations (which are often indicative of defects) over the revision history of a program, and for precisely attributing the introduction and elimination of these violations to individual developers. As one application, we demonstrate how this information can be used to compute ``fingerprints'' of developers that reflect which kinds of violations they tend to introduce or to fix. We have performed an experimental study on several large open-source projects written in different languages, providing evidence that these fingerprints are well-defined and capture characteristic information about the coding habits of individual developers.

Model driven development (MDD) of software product lines (SPLs)merges two increasing important paradigms that synthesize programs by transformation. MDD creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational model of a product line of scalar vector graphics and JavaScript applications. We explain how we simplified our implementation by lifting selected features and their compositions from our original product line (whose implementations were complex) to features and their compositions of another product line (whose specifications were simple). We used operators to map higher-level features and their compositions to their lower-level counterparts. Doing so exposed commuting relationships among feature compositions in both product lines that helped validate our model and implementation.

The emergence of multi -processor, multi-threaded architectures (referred to as multi-* architectures) facilitates the design of high-throughput request processing systems (e.g., multiservice routers for GENI, intrusion detection systems, graphics and gaming systems, as well as high-throughput web servers and transaction processing systems). Because of the challenges in programming such architectures, realizing this promise has proved to be difficult. In this paper, we describe the design of Lagniappe, a programming environment that simplifies the design of portable, high-throughput applications on multi-* architectures. Lagniappe uses a hybrid programming model: it combines a procedural specification (e.g., in C++) of the basic operators for processing requests with a declarative specification - expressed using a model-driven development framework - of the various features of the operators and the target hardware platform. Using the declarative specification, the Lagniappe programming environment automates the mapping of applications onto the multi-* platform, performs dynamic allocation of resources to operators, and ensures efficient and coherent accesses to persistent, shared state.

A new approach to structuring layered protocols using polymorphic service access points and type inheritance between protocol machines is presented Polymorphic service access points facil itate the exible instantiation of protocol machines containing the minimal functionality required by an application The type inheritance structure is induced by a vertical partitioning of the upper layers of the ISO Reference Model resulting in a non monolithic protocol stack that supports concur rent object oriented applications such as Actor systems The results presented represent a modest contribution to the research and practice of advanced protocol development The type structures in troduced demonstrate to software engineers particularly those developing layered systems software that object oriented programming techniques facilitate and enhance the implementation of layered architectures In addition the results presented provide justi cation for object oriented language designers that polymorphic and extensible type structures are useful for e ciently implementing layered communication protocol architectures

We survey the history, development and usage of directory services based on the Lightweight Directory Access Protocol (LDAP). We present a summary of the naming model, the schema model, the principal service models

We present a novel approach that enables automatic generation of code for the front end of a the need for a general approach that provides a syntaxtree level API independent of a specific tree implemencompiler. The proposed approach is based on a Tree Manipulation Language (TML). TML is implemented on top of C++ and adds symbolic computational properties to manipulate hierarchical structures. We introduce an XML-based intermediate representation (XIR) used with TML that dramatically improves various front-end compiler algorithms such as symbol table creation and lookup, and abstract syntax tree (AST) generation and traversal. The proposed approach results in multiple benefits, for example, the significant reduction of code required to build ASTs, symbol table, and inheritance hierarchies. We built a C# parser in order to illustrate the effectiveness of our approach.

article Free Access Share on An adaptive framework for developing multimedia software components Authors: Edward J. Posnak Univ. of Texas at Austin, Austin Univ. of Texas at Austin, AustinView Profile , R. Greg Lavender Univ. of Texas at Austin, Austin Univ. of Texas at Austin, AustinView Profile , Harrick M. Vin Univ. of Texas at Austin, Austin Univ. of Texas at Austin, AustinView Profile Authors Info & Claims Communications of the ACMVolume 40Issue 10Oct. 1997pp 43–47https://doi.org/10.1145/262793.262802Published:01 October 1997Publication History 15citation671DownloadsMetricsTotal Citations15Total Downloads671Last 12 Months18Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

The Adaptive Configuration pattern described in this paper decouples the compositional structure of modules, which perform transformations on a data stream, from the algorithms used to implement these modules. Both may be changed dynamically and independently, to allow an implementation to adapt its functionality and resource requirements to the run-time environment. This pattern distinguishes itself from purely configurable pipeline patterns by addressing the tension between modularity and performance.

367,059. Photographicprinting apparatus. TAUSCHEK, G., 1, Meinhartsdorferstrasse, Vienna. Nov. 24, 1930, No. 35388. Convention date, Nov. 25, 1929. [Class 98 (ii).] A statistical machine controlled by perforated record cards is combined with a photographicprinting machine, which is driven from the operating-mechanism of the statistical machine and is adapted to print addresses &c. on the record cards. As shown, the statistical machine is of the type in which record cards 7 taken from a magazine by a reciprocating dog 8 are fed by rollers 9 to a card-reading device 24. Address-plates 4 taken from a magazine are fed in succession along a guideway at rightangles to the path of the cards 7 to printing position beneath a platen 11, which is actuated by a cam 10 rotated with one of the rollers 9 and prints through an ink-ribbon 5. The plates 4, however, may be replaced by photographic negatives, in which case the record cards are coated with a sensitized emulsion and a source of light is used in place of the platen.

handler and consumer handler objects that run in separate threads and route messages from one or more remote suppliers to one or more remote consumers, respectively. When a supplier handler thread receives a message from a remote supplier, it uses an address field in the message to determine the corresponding consumer handler, whose thread then delivers the message to its remote consumer. When suppliers and consumers reside on separate hosts, the Gateway uses the connection-oriented TCP [1] protocol to provide reliable message delivery and end-to-end flow control. TCP’s flow control algorithm blocks fast senders when they produce messages more rapidly than slower receivers can process the messages. The entire Gateway should not block, however, while waiting for flow control to abate on outgoing TCP connections. To minimize blocking, therefore, each consumer handler can contain a thread-safe message queue that buffers new routing messages it receives from its supplier handler threads. One way to implement a thread-safe Message Queue is to use the Active Object pattern [2], which decouples the thread used to invoke a method from the thread used to execute the method. As shown in Figure 2, each message queue active object contains a bounded buffer and its own thread of control that maintains a queue of pending messages. Using

This paper describes the design of and implementation of Presentation Processing Engines (PPEs) that provide flexible control over QoS to manage heterogeneity in networks, end-systems and compression formats. Development of PPEs is facilitated by a framework that provides the modular architecture, data types, and transformations common to most codecs, filters, transcoders etc. to facilitate the implementation of emerging compression standards and their integration into media processing applications. By allowing fine-grained composition of compression and image processing modules, the framework facilitates the development of extensible presentation processing engines that can be dynamically configured to adapt to changes in resource availability and user preferences.

A \future" is a typed synchronization mechanism used to represent a value that will come into existence at some point in time after the creation of the future. In this paper, a polymorphic future type is introduced that di ers from previous mechanisms in that it provides a rst-class, extensible facility for expressing synchronized access to the typed result value of a concurrent computation. The proposed mechanism requires write-once/read-many synchronization, which is implemented in terms of common thread synchronization primitives, thereby ensuring a high-degree of e ciency. The type de nition and type specialization features of C++ are used to illustrate how one would implement a polymorphic future type in a strongly typed object-oriented language supporting polymorphic type de nitions.