Abstract: Traditional software engineering means have been characterized by a rather predictable process in the past. Users tell once and for all exactly what they want. Programmers design the system that will deliver those features. They code it; test it, and all is well. But all was not always well. The users did not tell once and for all exactly what they wanted. They changed their minds, and the users were not the only problem. Programmers could misjudge their progress. The academic software engineering community took the high cost of changing software as a challenge, creating technologies like relational databases, modular programming, and information hiding. This is where extreme programming comes in. Rather than planning, analyzing, and designing for the far-flung future, XP exploits the reduction in the cost of changing software to do all of these activities a little at a time, throughout software development. The paper discusses the major practices of XP.

Abstract: Reporting on the SWEBOK project, the authors-who represent the project's editorial team-discuss the three-phase plan to characterize a body of knowledge, a vital step toward developing software engineering as a profession.

Abstract: For anyone who designs applications or Web pages professionally, Software for Use provides an appealingly written guide to user interface design. This book delivers many valuable insights on improving interfaces for both desktop applications and Web sites. A software design process is first presented that's centered on usability (with terms like "user roles," "use cases," and "interaction contexts"). Early sections have much to say about inadequate interfaces (using a number of Windows examples) and how to improve them. The book presents an argument for creating innovative and intuitable interfaces (often by rethinking time-honored Windows conventions). The most provocative material here is the coverage of the Internet--the book argues that many Web sites sacrifice usability for visual razzle-dazzle, and it offers ways to organize Web sites for better usability. (A section on embedded devices looks at UI issues for these systems too.) A full case study of a user interface design for a corporate address book is included. Software for Use makes a good case that there is room for improvement in today's user interfaces. This book is sure to be a valuable resource for anyone serious about improving the user's experience of software or Web sites. --Richard Dragan Topics covered: Design processes; help systems and error messages; and interface creation for novice, intermediate, and advanced users.

Abstract: Highsmith, Addison-Wesley, 2013, 0133489485, 9780133489484, 392 pages. This is the digital version of the printed book (Copyright В© 2000). Ð’Â Winner of the 2001 Software Development Jolt Product Excellence Award Ð’Â This innovative textÐ’Â offers a practical, realistic approach to managing high-speed, high-change software development projects. Consultant James A. Highsmith shows readers how to increase collaboration and adapt to uncertainty. Ð’Â Many organizations start high-speed, high-change projects without knowing how to do themÐ2Ђ“and even worse, without knowing they donÐ2Ђ™t know. Successful completion of these projects is often at the expense of the project team. Ð’Â Adaptive Software Development emphasizes an adaptive, collaborative approach to software development. The concepts allow developers to Ð2ЂNsscale-upÐ2ЂNœ rapid application development and extreme programming approaches for use on larger, more complex projects. Ð’Â The four goals of the book are toÐ’Â support an adaptive culture or mindset, in which change and uncertainty are assumed to be the natural stateÐ2Ђ“not a false expectation of order introduce frameworks to guide the iterative process of managing change institute collaboration, the interaction of people on three levels: interpersonal, cultural, and structural add rigor and discipline to the RAD approach, making it scalable to the uncertainty and complexity of real-life undertakings Ð’Â .

Abstract: Computer software reliability has never been so important. Computers are used in areas as diverse as air traffic control, nuclear reactors, real-time military, industrial process control, security system control, biometric scan-systems, automotive, mechanical and safety control, and hospital patient monitoring systems. Many of these applications require critical functionality as software applications increase in size and complexity. This book is an introduction to software reliability engineering and a survey of the state-of-the-art techniques, methodologies and tools used to assess the reliability of software and combined software-hardware systems. Current research results are reported and future directions are signposted. This text will interest: graduate students as a course textbook introducing reliability engineering software; reliability engineers as a broad, up-to-date survey of the field; and researchers and lecturers in universities and research institutions as a one-volume reference.

Abstract: Recently, many formal methods, such as the SCR (Software Cost Reduction) requirements method, have been proposed for improving the quality of software specifications. Although improved specifications are valuable, the ultimate objective of software development is to produce software that satisfies its requirements. To evaluate the correctness of a software implementation, one can apply black-box testing to determine whether the implementation, given a sequence of system inputs, produces the correct system outputs. This paper describes a specification-based method for constructing a suite of test sequences, where a test sequence is a sequence of inputs and outputs for testing a software implementation. The test sequences are derived from a tabular SCR requirements specification containing diverse data types, i.e., integer, boolean, and enumerated types. From the functions defined in the SCR specification, the method forms a collection of predicates called branches, which “cover” all possible software behaviors described by the specification. Based on these predicates, the method then derives a suite of test sequences by using a model checker's ability to construct counterexamples. The paper presents the results of applying our method to four specifications, including a sizable component of a contractor specification of a real system.

Abstract: As the software radio makes its transition from research to practice, it becomes increasingly important to establish provable properties of the software radio architecture on which product developers and service providers can base technology insertion decisions. Establishing provable properties requires a mathematical perspective on the software radio architecture. This paper contributes to that perspective by critically reviewing the fundamental concept of the software radio, using mathematical models to characterize this rapidly emerging technology in the context of similar technologies like programmable digital radios. The software radio delivers dynamically defined services through programmable processing capacity that has the mathematical structure of the Turing machine. The bounded recursive functions, a subset of the total recursive functions, are shown to be the largest class of Turing-computable functions for which software radios exhibit provable stability in plug-and-play scenarios. Understanding the topological properties of the software radio architecture promotes plug-and-play applications and cost-effective reuse. Analysis of these topological properties yields a layered distributed virtual machine reference model and a set of architecture design principles for the software radio. These criteria may be useful in defining interfaces among hardware, middleware, and higher level software components that are needed for cost-effective software reuse.

Abstract: From the Publisher: Using UMLis designed to help any developer master effective software design with UML. This new edition has been fully revised to reflect UML 1.3.Experienced modeling language instructors Perdita Stevens and Rob Pooley focus on superior design techniques, comparing the available methodologies and offering advice on when to use each. They begin by describing the software process and lifecycle, and explaining how object-orientation and component-based engineering affect the design process. Next, they review each key UML 1.3 feature, including patterns, components, concurrency, types, and more.Using UML, Revised Editioncontains extensive case studies of real-life design, including real-time systems, data-oriented, and component-based designs. The book also contains a full section addressing the wider issues related to software design, including quality, testing, and organizational management. (Previous Edition: 0-201-36067-5.)For every developer interested in mastering UML.

Abstract: The analysis system is a collection, configuration and integration of software programs that reside on multiple interconnected computer platforms. The software, less computer operating systems, is a combination of sensor, analysis, data conversion, and visualization programs. The hardware platforms consist of several different types of interconnected computers, which share the software programs, data files, and visualization programs via a Local Area Network (LAN). This collection and integration of software and the migration to a single computer platform results in an approach to LAN/WAN monitoring in either a passive and/or active mode. The architecture permits digital data input from external sensors for analysis, display and correlation with data and displays derived from four major software concept groups. These are: Virus Computer Code Detection; Analysis of Computer Source and Executable Code; Dynamic Monitoring of Data Communication Networks; 3-D Visualization and Animation of Data.

Abstract: The use of performance analysis and prediction techniques by software designers and software engineers is at best inconsistent and at worst simply does not happen. This is principally because these techniques are seen as separate and difficult to apply. Work on software performance engineering, initiated by C.U. Smith (1990), has sought to bridge the gap but has had limited success. With the emergence of a widely accepted standard for software design, the Unified Modelling Language (UML), the time seems ripe for an attempt to integrate performance directly into this process, by exploiting the notation directly. The paper reviews past work in software performance engineering, summarises UML and presents encouraging results from merging these two techniques.

Abstract: Hecker, a developer at Netscape, discusses the business of commercial open-source software, including why a company might adopt an open-source model, how open-source licensing works, what business models might be usable and how various objections relating to open source might be answered

Abstract: Software version upgrades are distributed and instantiated in a distributed computing environment. This includes defining the required versions of software as the contents of a software version upgrade kit. The software upgrade kit is written, e.g. as a table of contents or a list, to a database to generate software upgrade kit tables. The tables are used to generate software version upgrade kits. The kits are then used as a source to download copies of the upgrade kits to clients to be upgraded. This enables upgrading the software on the client.

Abstract: Software deployment is an evolving collection of interrelated processes such as release, install, adapt, reconfigure, update, activate, deactivate, remove, and retire. The connectivity of large networks, such as the Internet, is affecting how software deployment is performed. It is necessary to introduce new software deployment technologies that leverage this connectivity. The Software Dock framework creates a distributed, agent based deployment framework to support the ongoing cooperation and negotiation among software producers themselves and among software producers and software consumers. This deployment framework is enabled by the use of a standardized deployment schema for describing software systems, called the Deployable Software Description (DSD) format. The Software Dock also employs agents to traverse between software producers and consumers in order to perform software deployment activities by interpreting the descriptions of software systems. The Software Dock infrastructure allows software producers to offer their customers high level deployment services that were previously not possible.

Abstract: The software clustering problem has attracted much attention recently, since it is an integral part of the process of reverse engineering large software systems. A key problem in this research is the difficulty in comparing different approaches in an objective fashion. In this paper, we present a metric, called MoJo (Move-Join), that can be used in evaluating the similarity of two different decompositions of a software system. Our metric calculates a distance between two partitions of the same set of software resources. We begin by introducing the model we use. Then we present a heuristic algorithm that calculates the distance in an efficient fashion. Finally, we discuss some experiments that showcase the performance of the algorithm and the effectiveness of the metric.

Abstract: Cleanroom software engineering is a process for developing and certifying high-reliability software. Combining theory-based engineering technologies in project management, incremental development, software specification and design, correctness verification, and statistical quality certification, the Cleanroom process answers today's call for more reliable software and provides methods for more cost-effective software development.Cleanroom originated with Harlan D. Mills, an IBM Fellow and a visionary in software engineering. Written by colleagues of Mills and some of the most experienced developers and practitioners of Cleanroom, Cleanroom Software Engineering provides a roadmap for software management, development, and testing as disciplined engineering practices. This book serves both as an introduction for those new to Cleanroom and as a reference guide for the growing practitioner community. Readers will discover a proven way to raise both quality and productivity in their software-intensive products, while reducing costs.Highlights Explains basic Cleanroom theory Introduces the sequence-based specification method Elaborates the full management, development, and certification process in a Cleanroom Reference Model (CRM) Shows how the Cleanroom process dovetails with the SEI's Capability Maturity Model for Software (CMM) Includes a large case study to illustrate how Cleanroom methods scale up to large projects.

Abstract: In practice, object-oriented design models have been less useful throughout the lifetime of software systems than they should be. Design models are often large and monolithic, and the structure of the designs is generally quite different from that of requirements. As a result, developers tend to discard the design, especially as the system evolves, since it is too difficult to keep its relationship to requirements and code accurate, especially when both are changing. This paper presents a different approach to designing systems, based on flexible decomposition and composition, that closely aligns designs with both requirements specifications and with code. We illustrate how this approach permits the benefits of designs to be maintained throughout a system’s lifetime.

Abstract: This hands-on tutorial shows how to develop tests that ensure the reliability of software systems. Software developers learn how to establish reliable objectives, develop operational profiles, and prepare and execute test cases, as well as about useful formulae and recommended software tools. FAQ sections in each chapgter provide a useful way to review or reference specific information, and practical exercises allow readers to immediately apply what they have learned. John D. Musa is the author of "Software Reliability: Measurement, Prediction, Application".

Abstract: Current object-oriented (OO) and component technologies suffer from several problems such as the lack of analysis and design methods for the development for reuse, lack of effective techniques for dealing with many variants of components, loss of design knowledge due to the semantic gap between domain abstractions and programming language features, and runtime performance penalties for clean and flexible design. This thesis proposes Generative Programming (GP) as a comprehensive software development paradigm to achieving high intentionality, reusability, and adaptability without the need to compromise the runtime performance and computing resources of the produced software. In the area of analysis and design for GP, we investigate Domain Engineering (DE) methods and their integration with OO analysis and design (OOA/D) methods. The main difference between DE methods and OOA/D methods is that the first are geared towards developing whole families of systems while the latter focus on developing single systems. We identify feature modeling as the main contribution of DE to OOA/D. Feature models represent the configurability aspect of reusable software at an abstract level, i.e. without committing to any particular implementation technique such as inheritance, aggregation, or parameterized classes. We give a precise and extended formulation of the feature diagram notation and investigate the relationship between feature modeling, OO modeling and AspectOriented Programming. In the area of implementation for GP, we study various metaprogramming technologies. We identify modularly extensible programming environments as the ideal programming platform for GP, which allows implementing domain-specific optimizations, domain-specific displaying and editing, domain-specific debugging and code analysis, new composition mechanisms, etc., in a scalable way. We also propose new implementation techniques such as configuration generators based on mixin models with automatic configuration and configuration repositories and make several contribution to template metaprogramming. Based on the analysis of the areas mentioned above, we propose a new Domain Engineering method for the development of algorithmic reusable libraries (DEMRAL), which integrates various DE, OO, and AOP concepts. We validate the method by applying it to the domain of matrix computations, which results in the development of the Generative Matrix Computation Library (GMCL). We provide two implementation GMCL, one using generative programming techniques in C++ and another one in Intentional Programming (an modularly extendible programming environment). In addition to validating the usefulness of DEMRAL, the GMCL case study provides a concrete comparison of two generative implementation technologies. The C++ implementation of the matrix component (which is a part of C++ GMCL) comprises only 7500 lines of C++ code, but it is capable of generating more than 1840 different kinds of matrices. Despite the large number of provided matrix variants, the performance of the generated code is comparable with the performance of manually coded variants. The application of template metaprogramming allowed a highly intentional library API and a highly efficient library implementation at the same time. The implementation of GMCL within the Intentional Programming system (IP) demonstrates the advantages of IP, particularly in the area of debugging and displaying.

Abstract: Extensible typesafe systems, such as Java, rely critically on a large and complex software base for their overall protection and integrity, and are therefore difficult to test and verify. Traditional testing techniques, such as manual test generation and formal verification, are too time consuming, expensive, and imprecise, or work only on abstract models of the implementation and are too simplistic. Consequently, commercial virtual machines deployed so far have exhibited numerous bugs and security holes.In this paper, we discuss our experience with using production grammars in testing large, complex and safety-critical software systems. Specifically, we describe lava, a domain specific language we have developed for specifying production grammars, and relate our experience with using lava to generate effective test suites for the Java virtual machine. We demonstrate the effectiveness of production grammars in generating complex test cases that can, when combined with comparative and variant testing techniques, achieve high code and value coverage. We also describe an extension to production grammars that enables concurrent generation of certificates for test cases. A certificate is a behavioral description that specifies the intended outcome of the generated test case, and therefore acts as an oracle by which the correctness of the tested system can be evaluated in isolation. We report the results of applying these testing techniques to commercial Java implementations. We conclude that the use of production grammars in combination with other automated testing techniques is a powerful and effective method for testing software systems, and is enabled by a special purpose language for specifying extended production grammars.

Abstract: Your organization can choose from three main strategies for improving its software productivity. You can work faster, using tools that automate or speed up previously labor-intensive tasks. You can work smarter, primarily through process improvements that avoid or reduce non-value-adding tasks. Or you can avoid unnecessary work by reusing software artifacts instead of custom developing each project. Which strategy will produce the highest payoff? The author performed an extensive analysis that addressed this question for the US Department of Defense. The result of this analysis showed that work avoidance via software reuse produced the highest improvement in software productivity. The article gives advice on how to manage software reuse and the pitfalls to avoid.

Abstract: A method for the prediction of software maintainability during software architecture design is presented. The method takes: the requirement specification; the design of the architecture; expertise from software engineers; and, possibly, historical data as input and generates a prediction of the average effort for a maintenance task. Scenarios are used by the method to concretize the maintainability requirements and to analyze the architecture for the prediction of the maintainability. The method is formulated based on extensive experience in software architecture design and detailed design and exemplified using the design of software architecture for a haemo dialysis machine. Experiments for evaluation and validation of the method are ongoing and future work.

Abstract: Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused “as-is”. Practitioners have found that “as-is” reuse seldom occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited support for component adaptation, i.e. white-box techniques such as copy–paste and inheritance, and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, efficiency, implementation overhead or the self problem. To address these problems, this article proposes superimposition, a novel black-box adaptation technique that allows one to impose predefined, but configurable types of functionality on a reusable component. Three categories of typical adaptation types are discussed, related to the component interface, component composition and component monitoring. Superimposition and the types of component adaptation are exemplified by several examples.

Abstract: The demand for educational software is growing exponentially with the surge of interest in educational reform, the Internet, and distance learning. Educational applications must be flexible because curricula and teaching styles vary greatly among institutions, locations, and even among instructors at the same institution. To meet these needs, a wide array of small-scale, casual developers at universities, research labs, and small businesses develop educational software, but no dominant solution or supplier has seemed to emerge. In this market, smaller suppliers often cannot produce full solutions without depending on the capabilities of other vendors. Until now, components have remained largely the province of full-time programmers. However, component technologies are likely to expand toward an audience that comprises considerably less technical and more domain-oriented users whose job descriptions typically don't include software development. Thus, the lessons learned could become increasingly important to developing good software for any application domain. Having component developers collaborate with domain experts to build applications may be the future of software development. This group of component developers discusses what they've learned in collaborating with educators on educational software components.

Abstract: The sections in this article are 1 Software Cost Estimation for the Practicing Software Engineer 2 Research Directions in Software Cost Modeling 3 Acknowledgements

Abstract: In this paper, an empirical study that links software process consistency with product defects is reported. Various measurement issues such as validity, reliability, and other challenges in measuring process consistency at the project level are discussed. A measurement scale for software process consistency is introduced. An empirical study that uses this scale to measure consistency in achieving the CMM goal questions in various key process areas (KPAs) in 45 projects at a leading software vendor is reported. The results of this analysis indicate that consistent adoption of practices specified in the CMM is associated with a lower number of defects. Even a relatively modest improvement in the consistency of implementing these practices is associated with a significant reduction in field defects.

Abstract: Formal verification methods are used only sparingly in software development. The most successful methods to date are based on the use of model checking tools. To use such tools, the user must first define a faithful abstraction of the application (the model), specify how the application interacts with its environment, and then formulate the properties that it should satisfy. Each step in this process can become an obstacle. To complete the verification process successfully often requires specialized knowledge of verification techniques and a considerable investment of time. In this paper we describe a verification method that requires little or no specialized knowledge in model construction. It allows us to extract models mechanically from the source of software applications, securing accuracy. Interface definitions and property specifications have meaningful defaults that can be adjusted when the checking process becomes more refined. All checks can be executed mechanically, even when the application itself continues to evolve. Compared to conventional software testing, the thoroughness of a check of this type is unprecedented.