Lightweight software development methods like eXtreme Programming (XP) can benefit from the expansion of their practices by the judicious application of techniques from other methods. This paper shows how Problem Frames can be coupled with the "stories" method of requirements capture used in XP to further explore the problem space and synergistically derive requirements.

this paper we present a sequence of laboratory exercises that blend the use of specific fundamental data structures, the software engineering concepts of reusability and extensibility and the object-oriented design paradigm. From an educational perspective there are several interesting aspects to the work presented in this paper.

Abstract. A list of fundamental principles of software engineering is viewed as needed to solidify the foundations of the field, thereby enabling and hastening the maturation of the discipline. Most of the authors who have investigated software engineering principles note that the discipline has a foundation. Some talk about principles, others about concepts, laws or notions, while they all agree with the view that a stable basis for the discipline is formed by their own individual set of these. However, this paper illustrates that there is a clear lack of consensus about which of the proposed principles are indeed fundamental. Furthermore, authors do not share the same definition of software engineering, nor do they share the same definition of the term ‘principle’. In summary, over 250 statements on what is meant by a principle are inventoried, and most are based only on the author’s opinion or point of view. Therefore, significant effort is still required to pursue this research topic relating to the foundation of software engineering. In particular, more work is required to design an appropriate research methodology, including precise definitions of the terms being used.

The topic of how to exploit parallelism for performance enhancement has already received considerable attention. However, relatively less attention has been paid to practical development techniques for parallel real-time applications. In this paper we propose a graphical design language for supporting the technical design phase in the process of parallel real-time application development. This design language is based on a model of Communicating Sequential Processes and Data Flow Diagrams and supports exploitation of task-oriented and data parallelism. Novel features include, besides support for exploitation of parallelism for real-time applications, a strict separation of behavior and communication specification, specification of timing constraints, integration of control flow and data transformations, and support for automated source code generation The paper also briefly pays attention to the current implementation of the language. Keywords: parallel processing, design languages, re...

The growing complexity of information systems and the ensuring problems of their development, maintenance and management have highlighted the inadequacy of formal and informal methods for constructing such systems. These problems manifest themselves in the computer systems which are often unmanageable, unreliable, inflexible and hence difficult to maintain. Users have often demanded for reliable computer systems because they realize that most failures are due to poor specification, and design. This has resulted in the emergence of a number of information systems methodologies together with associated computerized development environments in which the Object-Oriented (OO) approach is one of the most recent. OO is often used for promoting software development and its reuse. Languages like Smalltalk reduce not only development time but also the cost of maintenance, simplifying the creation of new systems and the reuse of old ones. Nevertheless OO is not a panacea i.e. efforts are to put i...

Software development efforts result in the delivery of a software product which satisfies user requirements. Accordingly, the software product must change or evolve. Once in

Abstract not found

. This paper describes a case study in which the Entity Life Modeling (ELM) [1] technique is used to reconstruct a single module from a legacy FORTRAN application. The architecture of the module changed as a result of entity identification and mode analysis. Concurrent aspects of the problem domain were identified and modeled as concurrent tasks. To interface with the greater part of the software system that was not reconstructed, an interface object was created. The interface object may be regarded as scaffolding that will be discarded when neighboring increments of the system are reengineered. The reengineered increment has a highly maintainable design that is characteristic of complete systems constructed using the ELM methodology. I. Introduction. Reengineering is the process of reusing old programs to generate replacements. Traditionally, reengineering has meant modifying code that has only imperfect or incomplete specification-level and design-level information. Such maintenanc...

The scope of this paper is to present a framework, a method and a formalism for Object Oriented Analysis, Design and Implementation, through a Prototyping phase, of distributed concurrent systems. The study has been motivated by Computer Integrated Manufacturing, or more generally, by applications which have highly layered control structures, and it is aimed at improving software reusability. The approach has been centered around a library of basic classes encompassing sequential, blocking and active objects. This library, which handles basic data structures, concurrency, discrete time events, as well as control and distribution, constitutes a kernel of basic modules that induces a unitary architectural framework which can represent complex hierachical and decentralized control systems. The approach has been implemented using the C++ language. The environment and tools supporting the method, and the formalism are not generic. They have, in fact, been conceived strictly for the devel...

types may not be used.