Requirements are the New Code

The standard-compliant development of component-based embedded systems calls for systematic coverage of product requirements and for testing component interactions at the system integration stage. System functionality is represented by a set of complex distributed functions, i.e., functions that are spread across several system components. This chapter presents a novel automated model-based testing approach for distributed functions that uses informal system requirements and component behavior models. The test modeling notation makes it possible to model component interactions and composite functions with defined pre- and post-conditions. Test cases are automatically generated as scenarios of distributed functions represented by sequences of component interactions.

Application Generator (AG) can help save time of software development. Some AG has its own DSL (Domain Specific Language) to direct the generated application outcome. In this research, we developed a DSL using the syntax notation text with simple structure that can assist AG in the process of generating source code for desktop-based database application using Java. DSL development is applying the methodology of DSL development from Czarnecki. The development for AG involves three areas of knowledge, i.e. domain engineering, DSL, and AG (compiler). Domain engineering is required to understand the target application domain to be generated, i.e. MySQL database and Java programming language with Swing UI. The DSL is developed in five phases, i.e. decision-making, analysis, design, implementation, and development. The AG itself is developed in Java platform. The DSL and AG developed in this research has shown that the DSL can help programmer to develop Java desktop-based database applications by utilizing DSL to map MySQL database into Java Swing UI, and employ AG to generate applications directly from DSL source. It is expected that further development of this research is to support more flexible application development.

We report on the application of SPIN for model-checking C source code which is generated out of a textual domain-specific language (DSL). We have built a tool which automatically generates the necessary SPIN wrapper code using (meta-)information available at the DSL level. The approach is part of a larger tool-chain for developing mission critical applications. The main purpose of SPIN is for bug-finding where error traces resulting from SPIN can be automatically replayed at the DSL level and yield concise explanations in terms of a temporal specification DSL. The tool-chain is applied in some large scale industrial applications.

One of the important modules of a black-box automatic program grader is a "checker". In programming competition environment, a checker is a program written for the purpose to check the output of the contestant's program for a task that has many solutions. Usually, a checker is written manually as needed. In this paper, the idea of the output checker in the programming competition environment is extended to input checker and source code checker as a part of the automatic grader in our programming learning environment. Input checker validates the input coverage. The source code checker is used to validate a set of properties from a source code against the given coding specification. A Domain-Specific Language (DSL) grammar is designed and developed as a specification for the automatic generation of the output, input, and source code checkers. The DSL grammar and the checker generator tool set are used to evaluate source codes in our programming class. By writing the checkers specification in DSL, the specification is automatically documented and can be reused for similar properties.

Innovation in the changing undergraduate engineering curriculum mandates efficient management of interdisciplinary capstone senior design projects. This effort requires collaboration and management of students and faculty from multiple disciplines, and provides students an opportunity to learn from other engineering disciplines. In addition, this approach will i) emphasize problem solving and creative thinking skills; ii) provide students first-hand experience in generating a management plan; iii) expose students to multiple engineering disciplines, and work in diverse, multi-cultural teams; and iv) prepare students with an in-depth understanding of the interdisciplinary skills necessary for success. The senior design project (SDP) presented is based on the interdisciplinary collaboration of electrical, computer, and mechanical engineering students and faculty to design an integrated high altitude balloon system that would reach an altitude of 100,000 feet and return safely to earth. This paper presents methods by which all the above issues are addressed, results obtained over the recent years.

Embedded Domain-Specific Languages (EDSLs) are an alternative to quickly implement specialized languages without the need to write compilers or interpreters from scratch. In this territory, Haskell is a prime choice as the host language. EDSLs in Haskell, however, are often incapable of reifying useful static information from the source code, namely variable binding names and source locations. Not having access to variable names directly affects EDSLs designed to generate low-level code, where the variables names in the generated code do not match those found in the source code—thus broadening the semantic gap among source and target code. Similarly, many existing EDSLs produce poor error messages due to the lack of knowledge of source locations where errors are generated.

We present ACRE, an Automated aspect creator, to use aspect-oriented programming (AOP) to perform memory, invariant and interferences testing for software programs written in C++. ACRE allows developers without knowledge in AOP to use aspects to test their programs without modifying the behavior of their source code. ACRE uses a domain-specific language (DSL), which statements testers insert into the source code like comments to describe the aspects to be used. The presence of DSL statements in the code does not modify the program's compilation and behavior. ACRE parses the DSL statements and automatically generates appropriate aspects that are then weaved into the source code to identify bugs due to memory leaks, incorrect algorithm implementation, or interference among threads. Thanks to the use of aspects and ACRE, testers can add or remove tests easily. Using an aspect generated by ACRE, we find a memory leak in a complex C++ software program, NOMAD, used in both industry and research. We also verify a crucial mathematical point of the algorithm behind NOMAD and collect data to find possible interference bugs, in NOMAD.

Any change to one component of a software system is likely to be felt in other components, a phenomenon known as ‘ripple effect’. Impact analysis is the process of identifying all those components of a system which may be affected by ripple effect. This requires a knowledge of the dependencies between components. A software system consists not only of the source code, but also of all life cycle work products including requirements, design and test documents. Any of these components may be the subject of a change request, and should therefore be included in impact analysis. The ripple propagation graph (RPG) for impact analysis, developed as part of the AMES (Application Management Environments and Support) project, models an application in such a way that dependencies can be traced in order to identify all affected components. It is an object-relationship model consisting of the components of a system at some level of granularity, and the various relationships between them. This paper describes the AMES RPG, and how the results of the application understanding (AU) toolset, developed (again as part of the AMES project) to support the process of gaining an understanding of an application, can be used to provide some of the data required to populate the RPG. © 1998 John Wiley & Sons, Ltd.

This paper presents an approach for automatic synthesis of software models. Software models are increasingly being used for representing software applications at a high abstraction level, and source code can usually be generated from these models. Creating application models can be a tedious task, and thus the presented approach automates this task. Based on a formal definition of the domain-specific language (DSL) and user-defined properties, we generate intended application models. These models can then be subject to further manual extensions or used as is. The approach is illustrated by a DSL from the train domain, and the automatic synthesis of train station models.

Over the last decade the United States Government has significantly increased its use of commercial-off-the-shelf (COTS) software as stand-alone solutions and as components in safety-critical systems. This increased use stems from the realization that pre-existing software products can be a means of lowering development costs, shortening development time, and keeping pace with the changing software market. The Federal government, particularly with regards to safety-critical systems, has found that COTS software is currently not plug-and-play, has significant tradeoffs, and usually contains a cradle-to-grave dependence on the software manufacturer. Unfortunately, there is currently no standard best commercial practice with regard to the acceptance of COTS software. Ad hoc attempts to apply standards for commercial software acceptance have been based upon subjective criteria and have proven to be imprecise and prone to error. Moreover, acceptability in safety-critical systems generally demands analysis of source code. Many software vendors, however, have chosen to keep all such source code proprietary due to liability and intellectual property concerns. When the source code is not available, there is very little that can be done to ensure the safety, reliability, and integrity of the software. This paper discusses the COTS Score, an approach that aids in determining the acceptability of COTS software. The process involves the application of predictive techniques used for financial credit scoring to the COTS domain. The methodology addresses the issue of acceptability by incorporating both functional and environmental software measures related to reliability, compatibility, certifiability, obsolescence, and life cycle including trade-off analyses. This approach satisfies NASA and ISO 9001 requirements to define an acceptance procedure for COTS software.

Web Applications (WAs) are complex systems and it is difficult to understand their architecture without proper documentation. Due to high pressure of meeting deadlines and short time to market, WAs are liable to be poorly structured and are rarely well documented. Even if documentation is present, it often does not comply with code because code is updated without updating documentation. This leads to problems during maintenance. To improve understanding of a system, attempts can be made to recover architecture from the source code by analyzing the relations and dependencies between a system's components. Architecture of WAs revolves around its web pages (WPs). In this paper, we present a tool for extracting relations between WPs within WAs. WAFE is capable of extracting a large number of relations, and uses combination of procedural language analysis and object oriented language analysis along with WP identifiers (name terms). Another important feature of WAFE tool is its language independence i.e. one can make it functional for any server side language by writing a few regular expressions.

This paper describes the design and evaluation of ProtoMol, a high performance object-oriented software framework for molecular dynamics (MD). The main objective of the framework is to provide an efficient implementation that is extensible and allows the prototyping of novel algorithms. This is achieved through a combination of generic and object-oriented programming techniques and a domain specific language. The program reuses design patterns without sacrificing performance. Parallelization using MPI is allowed in an incremental fashion. To show the flexibility of the design, several fast electrostatics (N-body) methods have been implemented and tested in ProtoMol. In particular, we show that an O(N) multi-grid method for N-body problems is faster than particle-mesh Ewald (PME) for N > 8,000. The method works in periodic and nonperiodic boundary conditions. Good parallel efficiency of the multi-grid method is demonstrated on an IBM p690 Regatta Turbo with up to 20 processors for systems with N = 102, 104 and 106. Binaries and source code are available free of charge at http://www.nd.edu/~lcls/protomol.

We advocate goal-oriented software security engineering to produce highly secure software in a constructive,provable and cost-effective manner. Our approach is to couple goal-oriented semi-formal requirements specifications with formal design and implementation. To this effect, we proposed FADES (formal analysis and design for engineering security)in as the first goal-oriented software security engineering approach that provides a systematic and automated bridge between the goal-directed semi-formal KAOS (knowledge acquisition for automated specifications) framework and the B formal method to derive formal design and implementation from security requirements. In this paper, we demonstrate the applicability of FADES and study its effectiveness through a generic Electronic Smart Card case study and a comparative analysis between FADES and strictly applying formal methods.We use the case study to demonstrate how the goal-oriented formulation of security requirements in FADES paves the way for formal design that provably preserves the security properties.Further, the results of the comparison between FADES and Z show that FADES achieves better requirements completeness,consistency and security quality.

The increasing use of model-driven software development has renewed emphasis on using domain-specific models during application development. More specifically, there has been emphasis on using domain-specific modeling languages (DSMLs) to capture user-specified requirements when creating applications. The current approach to realizing these applications is to translate DSML models into source code using several model-to-model and model-to-code transformations. This approach is still dependent on the underlying source code representation and only raises the level of abstraction during development. Experience has shown that developers will many times be required to manually modify the generated source code, which can be error-prone and time consuming. An alternative to the aforementioned approach involves using an interpreted domain-specific modeling language (i-DSML) whose models can be directly executed using a Domain Specific Virtual Machine (DSVM). Direct execution of i-DSML models require a semantically rich platform that reduces the gap between the application models and the underlying services required to realize the application. One layer in this platform is the domain-specific middleware that is responsible for the management and delivery of services in the specific domain. In this dissertation, we investigated the problem of designing the domain-specific middleware of the DSVM to facilitate the bifurcation of the semantics of the domain and the model of execution (MoE) while supporting runtime adaptation and validation. We approached our investigation by seeking solutions to the following sub-problems: (1) How can the domain-specific knowledge (DSK) semantics be separated from the MoE for a given domain? (2) How do we define a generic model of execution (GMoE) of the middleware so that it is adaptable and realizes DSK operations to support delivery of services? (3) How do we validate the realization of DSK operations at runtime? Our research into the domain-specific middleware was done using an i-DSML for the user-centric communication domain, Communication Modeling Language (CML), and for microgrid energy management domain, Microgrid Modeling Language (MGridML). We have successfully developed a methodology to separate the DSK and GMoE of the middleware of a DSVM that supports specialization for a given domain, and is able to perform adaptation and validation at runtime.

Developing an algorithm for a visualization prototype often involves the direct comparison of different development stages and design decisions, and even minor modifications may dramatically affect the results. While existing development tools provide visualizations for gaining general insight into performance and structural aspects of the source code, they neglect the central importance of result images unique to graphical algorithms. In this article, we present a novel approach that enables visualization programmers to simultaneously explore the evolution of their algorithm during the development phase together with its corresponding visual outcomes by providing an automatically updating meta visualization. Our interactive system allows for the direct comparison of all development states on both the visual and the source code level, by providing easy to use navigation and comparison tools. The on-the-fly construction of difference images, source code differences, and a visual representation of the source code structure further enhance the user's insight into the states' interconnected changes over time. Our solution is accessible via a web-based interface that provides GPU-accelerated live execution of C++ and GLSL code, as well as supporting a domain-specific programming language for scientific visualization.