447257
Techniques and processes for improving the quality and performance of open-source software
Open-source development processes have emerged as an effective approach to reduce cycle-time and decrease design, implementation, and quality assurance (QA) costs for certain types of software, particularly systems infrastructure software, such as operating systems (OS), compilers and language processing tools, text and drawing editors, and middleware. This article presents two contributions to the study of open-source software processes. First, we describe key challenges of open-source software and illustrate how QA processes—specifically those tailored to open-source development—help mitigate these challenges better than traditional closed-source processes do. Second, we summarize results of empirical studies that evaluate how our Skoll distributed continuous quality assurance (DCQA) techniques and processes help to resolve key challenges in developing and validating open-source software. Our results show that: (a) using models to configure and guide the DCQA process improves developer understanding of open-source software, (b) improving the diversity of platform configurations helps QA engineers find defects missed during conventional testing, and (c) centralizing control of QA activities helps to eliminate redundant work. Copyright © 2006 John Wiley & Sons, Ltd.
29229734
Policies and patterns for high-performance, real-time object request brokers
Middleware is becoming increasingly important for building flexible communication systems that reduce software development cycle time and effort. Unfortunately, conventional middleware implementations of CORBA have historically lacked the efficiency, predictability, and scalability required by real-time systems. A decade of intensive R&D on design techniques and optimization principle patterns has recently converged, however, to yield high-performance and real-time middleware that can meet end-to-end Quality of Service (QoS) requirements for real-time systems. This tutorial outlines recent advances in real-time middleware, focusing on the policies and patterns in Real-time CORBA. Real-time CORBA defines a standard set of interfaces and capabilities to manage CPU, network, and memory resources predictably and efficiently end-to-end. This tutorial will illustrate via real world examples the key features and policies in the Real-time CORBA programming model. It will also describe the patterns that can be applied in ORB architectures to minimize priority inversion and non-determinism, associate client requests with servants in constant time, and implement standard and custom middleware protocols using small memory footprints. The patterns and optimizations covered in the tutorial are based on TAO, which is a widely used open-source real-time ORB that supports end-to-end QoS guarantees over a range of networks and embedded system interconnects. TAO is currently deployed at Boeing, Lockheed, Lucent, Motorola, Nokia, Nortel, Raytheon, SAIC, and Siemens, where it is used for real-time avionics, simulations, and telecommunications systems. Source code, documentation, and technical papers on TAO are available at www.cs.wustl.edu/~schmidt/TAO.html. Douglas Schmidt is an Associate Professor in the Electrical and Computer Engineering Department at the University of California, Irvine. Previously, he was Director of the Center for Distributed Object Computing and an Associate Professor of Department of Computer Science and the Department of Radiology at Washington University in St. Louis, Missouri, USA.His research focuses on design patterns, implementation, and experimental analysis of object-oriented frameworks that facilitate the development of high-performance, real-time distributed object computing systems on parallel processing platforms running over high-speed networks and embedded system interconnects. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE Dr. Schmidt is an internationally recognized expert on distributed object computing and has published widely in top IEEE, ACM, IFIP, and USENIX technical conferences and journals on topics ranging from high-performance communication software systems and parallel processing for high-speed networking protocols to real-time distributed object computing with CORBA and object-oriented design patterns. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE
2701566
Evaluating policies and mechanisms to support distributed real-time applications with CORBA
To be an effective platform for performance-sensitive real-time systems, commodity-off-the-shelf (COTS) distributed object computing (DOC) middleware must support application quality of service (QoS) requirements end-to-end. However, conventional COTS DOC middleware does not provide this support, which makes it unsuited for applications with stringent latency, determinism, and priority preservation requirements. It is essential, therefore, to develop standards-based, COTS DOC middleware that permits the specification, allocation, and enforcement of application QoS requirements end-to-end. 
 
The real-time CORBA and messaging specifications in the CORBA 2.4 standard are important steps towards defining standards-based, COTS DOC middleware that can deliver end-to-end QoS support at multiple levels in distributed and embedded real-time systems. These specifications still lack sufficient detail, however, to portably configure and control processor, communication, and memory resources for applications with stringent QoS requirements. 
 
This paper provides four contributions to research on real-time DOC middleware. First, we illustrate how the CORBA 2.4 real-time and messaging specifications provide a starting point to address the needs of an important class of applications with stringent real-time requirements. Second, we illustrate how the CORBA 2.4 specifications are not sufficient to solve all the issues within this application domain. Third, we describe how we have implemented portions of these specifications, as well as several enhancements, using TAO, which is our open-source real-time CORBA ORB. Finally, we evaluate the performance of TAO empirically to illustrate how its features address the QoS requirements for certain classes of real-time applications. Copyright © 2001 John Wiley & Sons, Ltd.
1561734
The Design and Performance of a Real-Time CORBA Scheduling Service
There is increasing demandto extend CORBA middleware to support applications with stringentquality of service (QoS) requirements. However, conventionalCORBA middleware does not define standard features to dynamicallyschedule operations for applications that possess deterministicreal-time requirements. This paper presents three contributionsto the study of real-time CORBA operation scheduling strategies.First, we document our evolution from static to dynamic schedulingfor applications with deterministic real-time requirements. Second,we describe the flexible scheduling service framework in ourreal-time CORBA implementation, TAO, which supports core schedulingstrategies efficiently. Third, we present results from empiricalbenchmarks that quantify the behavior of these scheduling strategiesand assess the overhead of dynamic scheduling in TAO. Our empiricalresults using TAO show that dynamic scheduling of CORBA operationscan be deterministic and can achieve acceptable latency for operations,even with moderate levels of queueing.
8854332
The design of the TAO real-time object request broker
Many real-time application domains can benefit from flexible and open distributed architectures, such as those defined by the CORBA specification. CORBA is an architecture for distributed object computing being standardized by the OMG. Although CORBA is well-suited for conventional request/response applications, CORBA implementations are not yet suited for real-time applications due to the lack of key quality of service (QoS) features and performance optimizations. This paper makes three contributions to the design of real-time CORBA systems. First, the paper describes the design of TAO, which is our high-performance, real-time CORBA 2.0-compliant implementation that runs on a range of OS platforms with real-time features including VxWorks, Chorus, Solaris 2.x, and Windows NT. Second, it presents TAO's real-time scheduling service that can provide QoS guarantees for deterministic real-time CORBA applications. Finally, the paper presents performance measurements that demonstrate the effects of priority inversion and non-determinism in conventional CORBA implementations and how these hazards are avoided in TAO.
6993185
Metric-driven analysis and feedback systems for enabling empirically guided software development
The authors summarize the goals of metric-driven analysis and feedback systems and describe a prototype system, Amadeus, which defines abstract interfaces and embodies architectural principles for these types of systems. Metric-driven analysis and feedback systems enable developers to define empirically guided processes for software development and maintenance. The authors provide an overview of the Amadeus system operation, including an example of the empirically guided process, a description of the system characteristics, an explanation of the system conceptual operation, and a summary of the users' view of the system. The centerpiece of the system is a pro-active server, which interprets scripts and coordinates event monitoring and agent activation. Amadeus provides an extensible framework for adding new empirically based analysis techniques.<<ETX>>
37519260
Trace-Based Abstract Interpretation of Operational Semantics
We present trace-based abstract interpretation, a unification of severallines of research on applying Cousot-Cousot-style abstract interpretation a.i. tooperational semantics definitions (such as flowchart, big-step, and small-step semantics)that express a program‘s semantics as a concrete computation tree of trace paths. Aprogram‘s trace-based a.i. is also a computation tree whose nodes contain abstractions ofstate and whose paths simulate the paths in the program‘s concrete computation tree.Using such computation trees, we provide a simple explanation of the central concept of collecting semantics, and we distinguish concrete from abstract collectingsemantics and state-based from path-based collecting semantics. We also expose therelationship between collecting semantics extraction and results garnered from flow-analytic and model-checking-based analysis techniques. We adapt concepts fromconcurrency theory to formalize “safe” and “live” a.i.‘s for computation trees; in particular, coinduction techniques help extend fundamental results to infinite computation trees.Problems specific to the various operational semantics methodologies are discussed: Big-step semantics cannot express divergence, so we employ a mixture of induction andcoinduction in response; small-step semantics generate sequences of programconfigurations unbounded in size, so we abstractly interpret source language syntax.Applications of trace-based a.i. to data-flow analysis, model checking, closure analysis,and concurrency theory are demonstrated.
207196655
Programming language semantics
A programming language possesses syntax and semantics. Syntax refers to the spelling of the language’s programs, and semantics refers to the meanings of the programs. A language’s syntax is formalized by a grammar or syntax chart; such formalizations are found in the back of language manuals. A language’s semantics should be formalized, too, and this is the topic of this chapter. Before we begin, we might ask, “What do we gain by formalizing the semantics of a programming language?” Consider the related question, “What was gained when language syntax was formalized with BNF?” • A language’s syntax definition standardizes the official syntax. This is crucial to users, who require a guide to writing syntactically correct programs, and to implementors, who must write a correct parser for the language’s compiler. • The syntax definition permits a formal analysis of its properties, such as whether the definition is LL(k), LR(k), or ambiguous. • The syntax definition can be used as input to a compiler front-end generating tool, such as YACC; it becomes, in effect, the implementation. We derive similar benefits from a formal semantics definition: • The semantics definition standardizes the official semanticsof the language. This is crucial to users, who require a guide to understanding the programs that they write, and to implementors, who must write a correct code generator for the language’s compiler. • The semantics definition permits a formal analysis of its properties, such as whether the definition is strongly typed, block structured, uses single-threaded data structures, is parallelizable, etc. • The semantics definition can be used as input to a compiler back-end generating tool [26, 31]; it becomes, in effect, the implementation. Programming-language syntax was studied intensively in the 1960’s and 1970’s, and programming language semantics is undergoing similar intensive study. Unlike the acceptance of BNF as the standard for syntax definition, it is unlikely that a single definition method will take hold for semantics—semantics is harder to formalize than syntax, and it has a wider variety of applications. Semantics-definition methods fall roughly into three groups:
6204500
Underapproximating Predicate Transformers
We study the underapproximation of the predicate transformers used to give semantics to the modalities in dynamic and temporal logic. Because predicate transformers operate on state sets, we define appropriate powerdomains for sound approximation. We study four such domains — two are based on “set inclusion” approximation, and two are based on “quantification” approximation — and we apply the domains to synthesize the most precise, underapproximating $\widetilde{pre}$ and pre transformers, in the latter case, introducing a focus operation. We also show why the expected abstractions of post and $\widetilde{post}$ are unsound, and we use the powerdomains to guide us to correct, sound underapproximations.
42747855
Action Semantics-Directed Prototyping
We present a methodology for compiler synthesis based on Mosses-Watt's action semantics. Each action in action semantics notation is assigned specific ''analysis functions'', such as a typing function and a binding-time function. When a language is given an action semantics, the typing and binding-time functions for the individual actions compose into typing and binding-time analyses for the language; these are implemented as the type checker and static semantics processor, respectively, in the synthesized compiler. Other analyses can be similarly formalized and implemented. We show a sample language semantics and its synthesized compiler, and we describe the compiler synthesizer that we have developed.
207550710
Induction, Domains, Calculi: Strachey's Contributions to Programming-Language Engineering
In collaboration with his colleagues at Oxford, Christopher Strachey pioneered the analysis of programming languages in terms of semantic features. Three of Strachey's contributions—inductive definition of semantics, semantic-domain definitions, and calculi for semantic description—are presented, and their consequences on languages research are described. Strachey's impact, present and future, on the computer programming “mainstream” is also outlined.