Abstract: An automated software production system is provided, in which system requirements are captured, converted into a formal specification, and validated for correctness and completeness. In addition, a translator is provided to automatically generate a complete, robust software application based on the validated formal specification, including user-interface code and error handling code.

Abstract: This paper introduces the OROCOS project that aims at becoming a general-purpose and open robot control software package. OROCOS follows the open source development model that has been proven to work in many other general-purpose software packages, such as Linux, Apache, Perl or LATEX. The paper focuses on the long-term vision of this start-up project, motivates which strategic and innovative design decisions are to be taken (a CORBA-like component architecture being the most important one), and lists other projects on which OROCOS could build. The success of OROCOS depends critically on how many researchers and engineers can be motivated to contribute code, documentation and feedback to the project.

Abstract: The authors discuss the notion of variability. We have experienced that this concept has so far been underdefined, although we have observed that variability techniques become increasingly important. A clear indication of this trend is the recent emergence of software product lines. Software product lines are large, industrial software systems intended to specialize into specific software products. The authors provide a framework of terminology and concepts regarding variability. In addition, they present three recurring patterns of variability. Finally, they suggest a method for managing variability in software product lines.

Abstract: Component-based development promises to revolutionize the way in which software is developed and maintained. However, contemporary component technologies, such as COM+/.NET, EJB/J2EE and CORBA, only support components in the final, implementation-oriented stages of development, leaving the earlier stages of analysis and design to be organized in largely traditional, non-component oriented ways. This book describes the KobrA method, which supports a model-driven, UML-based representation of components, and a product line approach to their development and evolution. This enables the benefits of component-based development to be realized throughout the software life-cycle, and allows the reusability of components to be significantly enhanced.

Abstract: Embedded products have become so complex and must be developed so quickly that current design methodologies are no longer adequate. The authors' vision for the future of embedded-system design involves two essential components: a rigorous methodology for embedded software development and platform-based design.

Abstract: The artifacts constituting a software system often drift apart over time. We have developed the software reflexion model technique to help engineers perform various software engineering tasks by exploiting, rather than removing, the drift between design and implementation. More specifically, the technique helps an engineer compare artifacts by summarizing where one artifact (such as a design) is consistent with and inconsistent with another artifact (such as source). The technique can be applied to help a software engineer evolve a structural mental model of a system to the point that it is "good enough" to be used for reasoning about a task at hand. The software reflexion model technique has been applied to support a variety of tasks, including design conformance, change assessment, and an experimental reengineering of the million-lines-of-code Microsoft Excel product. We provide a formal characterization of the reflexion model technique, discuss practical aspects of the approach, relate experiences of applying the approach and tools, and place the technique into the context of related work.

Abstract: The past two decades have seen increasing sophistication in software work. Now and in the future, the work of both practitioners and researchers would be helped by a more objective and finer granularity recognition of types of software evolution and software maintenance activities as actually done. To these ends, this paper proposes a clarifying redefinition of the types of software evolution and software maintenance. The paper bases the proposed classification not on people's intentions but upon objective evidence of maintainers' activities ascertainable from observation of activities and artifacts, and/or a before and after comparison of the software documentation. The classification includes taking into account in a semi-hierarchical manner evidence of the change or lack thereof in: (1) the software, (2) the documentation, (3) the properties of the software, and (4) the customer-experienced functionality. A comparison is made with other classifications and typologies. The paper provides a classified list of maintenance activities and a condensed decision tree as a summary guide to the proposed evidence-based classification of the types of software evolution and software maintenance. Copyright © 2001 John Wiley & Sons, Ltd.

Abstract: Dynamic classification of sections of software using a profile-based optimization system optimizes management of the sections of software. Software executes under expected usage conditions. After execution, a set of usage profiles describes the dynamic properties of sections of the software. Each usage profile includes information identifying a section of software. Each usage profile maps to an outcome meant to optimize management of the sections of the software during later execution. During such later execution, a usage background describes the dynamic properties of a section of the software. The usage background includes information identifying the section of software. By matching the usage background to a usage profile in the set of usage profiles, the section is dynamically classified during later execution. Based on this dynamic classification, the section maps to the outcome meant to optimize management of the sections of software.

Abstract: This paper concerns new techniques for making requirements specifications precise, concise, unambiguous, and easy to check for completeness and consistency. The techniques are well-suited for complex real-time software systems; they were developed to document the requirements of existing flight software for the Navy's A-7 aircraft. The paper outlines the information that belongs in a requirements document and discusses the objectives behind the techniques. Each technique is described and illustrated with examples from the A-7 document. The purpose of the paper is to introduce the A-7 document as a model of a disciplined approach to requirements specification; the document is available to anyone who wishes to see a fully worked-out example of the approach.

Abstract: When first formulated in the early seventies, the i>laws of software evolution were, for a number of reasons, not widely accepted as relevant to software engineering practice. Over the years, however, they have gradually become recognised as providing useful inputs to understanding of the software process. Now eight in number, they have been supplemented by the software uncertainty principle and the FEAST (i>Feedback, i>Evolution i>And i>Software i>Technology) hypothesis. Based on all these and on the further results of the FEAST research projects this paper develops and presents some fifty rules for application in software system process planning and management and indicates tools available or that could usefully be developed to support their application. The listing is structured according to the laws that encapsulate the observed phenomena and that lead to the recommendations. Each sublist is preceded by a textual discussion providing at least some of the reasoning that has led to the recommended procedures. The references direct the interested reader to the literature that records observed behaviours, interpretations, models and metrics obtained from industrially evolved systems, and from which the recommendations were derived.

Abstract: Software Fault Tolerance Techniques and Implementation examines key programming techniques such as assertions, checkpointing, and atomic actions, and provides design tips and models to assist in the development of critical fault tolerant software that helps ensure dependable performance. From software reliability, recovery, and redundancy, to design and data diverse software fault tolerance techniques, this practical reference provides detailed insight into techniques that can improve the overall dependability of software.

Abstract: We present a logic that can express properties of freshness, secrecy, structure, and behavior of concurrent systems. In addition to standard logical and temporal operators, our logic includes spatial operations corresponding to composition, local name restriction, and a primitive fresh name quantifier. Properties can also be defined by recursion; a central theme of this paper is then the combination of a logical notion of freshness with inductive and coinductive definitions of properties.

Abstract: A system for integrated computer software application development and modeling is herein described. The integrated system includes an expert system that can be supplied as a software plug-in to assist a software developer in designing and constructing software applications using uniform modeling language (UML) object modeling. In one embodiment the plug-in works with Rational Software Corporation's Rational Rose modeling product and can be used to develop software applications for use with M3 and the Weblogic family of transaction and application server products from BEA Systems, Inc, and with other third-party software systems.

Abstract: Readings in Hardware/Software Co-Design presents the papers that have shaped the hardware/software co-design field since its inception in the early 1990s Field experts Giovanni De Micheli, Rolf Ernst, and Wayne Wolf introduce sections of the book and provide context for the papers that follow This collection provides professionals, researchers, and graduate students with a single reference source for this critical aspect of computing design

Abstract: Software Design --- Cognitive Aspects covers a variety of areas including software analysis, design, coding and maintenance. It details the history of the research that has been conducted since the 1970s in this fast-developing field before defining a computer program from a computing and cognitive psychology viewpoint. Detailed treatment is given to the two essential sides of programming: software production and software understanding, and throughout the book parallels are drawn between studies on processing texts written in natural language and processing computer programs.

Abstract: The primary role of component-based software engineering is to address the development of systems as an assembly of parts (components), the development of parts as reusable entities, and the maintenance and upgrading of systems by customising and replacing such parts. This requires established methodologies and tool support covering the entire component and system lifecycle including technological, organisational, marketing, legal, and other aspects. The traditional disciplines from software engineering need new methodologies to support component-based development. IVICA CRNKOVIC assesses the challenges of this emerging technology and discusses its implications for the software development process. Copyright © 2002 John Wiley & Sons, Ltd.

Abstract: Most complex systems today contain software, and systems failures activated by software faults can provide lessons for software development practices and software quality assurance. This paper presents an analysis of software-related failures of medical devices that caused no death or injury but led to recalls by the manufacturers. The analysis categorizes the failures by their symptoms and faults, and discusses methods of preventing and detecting faults in each category. The nature of the faults provides lessons about the value of generally accepted quality practices for prevention and detection methods applied prior to system release. It also provides some insight into the need for formal requirements specification and for improved testing of complex hardware-software systems.

Abstract: SUMMARY To formally verify a large software application, the standard method is to invest a considerable amount of time and expertise into the manual construction of an abstract model, which is then analysed for its properties by either a mechanized or a human prover. There are two problems with this approach. The first problem is that this verification method can be no more reliable than the humans that perform the manual steps. If the average rate of error for human work is a function of the problem size, this holds not only for the construction of the original application, but also for the construction of the model. The standard verification trajectory therefore tends to become less reliable for larger applications. The second problem is one of timing and relevance. Software applications built by teams of programmers can change rapidly, often daily. Manually constructing an accurate abstraction of any one version of the application, though, can take weeks, which may jeopardize the validity of the results. In this paper a different verification method that avoids these problems is discussed. This method, which may be the precursor of a new class of testing techniques, was originally developed to allow for a thorough testing of parts of the software of a new commercial telephone switch. Here it is argued, though, that the method also has broad applicability to distributed software systems design in general.

Abstract: Software product lines (or system families) have achieved considerable adoption by the software industry. A software product line captures the commonalities between a set of products while providing for the differences. Differences are managed by delaying design decisions, thereby introducing variation points. The whole of variation points is typically referred to as the variability of the software product line. Variability management is, however, not a trivial activity and several issues exist, both in general as well as specific to individual phases in the lifecycle. This paper identifies and describes several variability issues based on practical experiences and theoretical understanding of the problem domain.

Abstract: This book provides the first comprehensive set of software patterns to support the development of embedded software systems. With a focus on reliability it discusses techniques for the design and implementation of software for embedded applications based on the popular 8051 microcontroller family.

Abstract: As the demand for more flexible, adaptable, extensible, and robust Web based enterprise application systems accelerates, adopting new software engineering methodologies and development strategies becomes critical. These strategies must support the construction of enterprise software systems that assemble highly flexible software components written at different times by various developers. Traditional software development strategies and engineering methodologies, which require development of software systems from scratch, fall short in this regard. Component based software engineering offers an attractive alternative for building Web based enterprise application systems. CBSE works by developing and evolving software from selected reusable software components, then assembling them within appropriate software architectures. By promoting the use of software components that commercial vendors or in-house developers build, the component based software development approach promises large scale software reuse.

Abstract: 0 7 4 0 7 4 5 9 / 0 1 / $ 1 0 . 0 0 © 2 0 0 1 I E E E T his month’s column is simply a collection of what I consider to be facts— truths, if you will—about software engineering. I’m presenting this software engineering laundry list because far too many people who call themselves software engineers, or computer scientists, or programmers, or whatever nom du jour you prefer, either aren’t familiar with these facts or have forgotten them. I don’t expect you to agree with all these facts; some of them might even upset you. Great! Then we can begin a dialog about which facts really are facts and which are merely figments of my vivid loyal opposition imagination! Enough preliminaries. Here are the most frequently forgotten fundamental facts about software engineering. Some are of vital importance—we forget them at considerable risk.

Abstract: Book Outline Chapter 1 Specification Product definition Performance constraints and objectives Cost objectives Schedule Hardware options Operating System options Development tool options Chapter 2 Partition Identifying software and hardware elements Determining optimal partitioning between software and hardware Risk management Modeling system behavior Chapter 3 Design phase Hardware design ASICs Boards FPGA's Custom integrated circuits Processor and memory systems Firmware design for low-level hardware driver code Software design to implement the product functionality Chapter 4 Integration phase Marrying hardware prototypes and software Integration and Debug Chapter 5 Validation phase Testing against compliance standards Measuring against performance objectives Return to development phase to correct any performance shortcomings Testing mission critical software for compliance to safety standards Chapter 6 Release Revision control for design software and schematics Final product testing Abuse Environmental RFI compliance Black-box White box Chapter 7 Maintenance and upgrades Product Release Customer Feedback Periodic enhancements or repairs Different design tearns for product support

Abstract: Reviews the problems, solutions and open issues in global software development (GSD), in which the software development activities are distributed across multiple sites. First, we introduce the reasons why GSD is becoming more and more prevalent. Then we outline the issues created or amplified by GSD and illustrate various effects it has on a software project. Finally, we summarize the literature on existing approaches to reduce the negative effects of GSD and list key open research questions.

Abstract: Agent-Oriented Software Engineering is the one of the most recent contributions to the field of Software Engineering. It has several benefits compared to existing development approaches, in particular the ability to let agents represent high-level abstractions of active entities in a software system. This paper gives an overview of recent research and industrial applications of both general high-level methodologies and on more specific design methodologies for industry-strength software engineering.

Abstract: A common extensible software configuration markup language (XSCML) is provided which is suitable to define a project related to the development or update of a software product. The common XSCML may be based on the Extensible Markup Language (XML). In accordance with the XSCML, a software project definition and a system independent software configuration framework are generated. An XSCML processor is provided to access the project definition and to describe product elements and processes and define their access parameters and their relations among each other.

Abstract: Repair Plan Concrete Repair Plan Resource Plan Syn the size d S ent ine ls Pla n S truc ture s alerts Development Environment Runtime Environment Figure 1: Dynamic Domain Architecture Approach: Our approach to building adaptive software is based on the notion of a Dynamic Domain Architecture (DDA) (see Figure 1). Dynamic Domain Architectures structure an application domain into layers of common services where each service has a number of variant implementations tailored to different environmental conditions. The architectural level of description also provides ”purpose links” which explain how the components of service

Abstract: Dynamic geometry software provides tools for students to construct and experiment with geometrical objects and relationships. On the basis of their experimentation, students make conjectures that can be tested with the tools available. In this paper, we explore the role of software tools in geometry problem solving and how these tools, in interaction with activities that embed the goals of teachers and students, mediate the problem solving process. Through analysis of successful student responses, we show how dynamic software tools can not only scaffold the solution process but also help students move from argumentation to logical deduction. However, by reference to the work of less successful students, we illustrate how software tools that cannot be programmed to fit the goals of the students may prevent them from expressing their (correct) mathematical ideas and thus impede their problem solution.