Michael Goedicke

A Meta-model for Representing Variability in Product Family Development

Effective product family based development depends on exploiting the commonality and variability in customer requirements. The desirability of variability in products is driven by the (manifest and hidden) needs of the various target market segments identified by various organizational units like sales and marketing. These are informed by other critical components of the context in which product families are developed including the technological capabilities, people/human resources available with the organization, the policies and procedures of the organization, and the strategic objective of the organization. Variability Management is seen as the key aspect that differentiates conventional software engineering and software product line engineering [Kruger 02]. Variability in a product family is defined as a measure of how members of a family may differ from each other [WeissLai 99]. Variability is made explicit using variation points. Variation points are places in design artifacts where a specific decision has been narrowed to several options but the option to be chosen for a particular system has been left open [Atkinson 01]. Identification of the points of variability is crucial in proliferating variety from a single product platform. A central component of product family approach is the management of variability. The product family development process involves managing variations among different members of the family by identifying common and variable aspects in the domain under consideration.

Dynamic Change Management by Distributed Graph Transformation: Towards Configurable Distributed Systems

In this contribution we consider the application of distributed graph transformation to the problem of specifying dynamic change in distributed systems. Change in distributed systems is related to at least two levels. One is the management of change in a local node of the distributed system and how such a local change is then propagated to those nodes which need to know about the change. The other aspect is changing the structure of the distributed system itself. This implies e.g. to add and/or remove a local node or an entire subsystem to/from the distributed system. In some important application areas such operations must be done during runtime without disturbing the unmodified rest of the distributed computing system. We first give an overview of our model of change and how exactly the two aspects of change interact. We describe distributed graph transformation as a technique to realize our change model. An example – a ring database – then shows how our approach can be applied to a small but nontrivial distributed system. This example shows nicely how the two aspects of change can be described uniformly using graph transformation rules and how the interaction of the two change aspects can be defined in an adequate way. Since this is ongoing work we conclude with an assessment of our approach and a brief discussion of further work.

ViewPoint-oriented software development by distributed graph transformation: towards a basis for living with inconsistencies

Software development is a staged and evolutionary process. Multiple stakeholders with different needs and views collaborate to build a system from interoperating and heterogeneous development artifacts. In such a setting, one has to cope with requirements changing dynamically during the entire lifetime of the system. Within this changing world living with inconsistencies is natural. Tool support is needed to tolerate inconsistencies and help developers to use them to drive the development process forward. In this contribution we consider the application of distributed graph transformation to the problem of formalizing the integration of multiple perspectives in software development called ViewPoints. Our work concentrates on requirements engineering. We demonstrate how inconsistency management can be used as a tool for requirements analysis by presenting a sample integration of architecture design and performance evaluation views.

Report on the Second SEMAT Workshop on General Theory of Software Engineering (GTSE 2013)

Many academic disciplines have general theories, which apply across the discipline and underlie much of its research. Examples include the Big Bang theory (cosmology), Maxwells equations (electrodynamics), the theories of the cell and evolution (biology), the theory of supply and demand (economics), and the general theory of crime (criminology). Software engineering, in contrast, has no widely-accepted general theory. Consequently, the SEMAT Initiative organized a workshop to encourage development of general theory in software engineering. Workshop participants reached broad consensus that software engineering would benefit from better theoretical foundations, which require diverse theoretical approaches, consensus on a primary dependent variable and better instrumentation and descriptive research.

Designing runtime variation points in product line architectures: three cases

Software product lines provide a common architecture, reusable code, and other common assets for a set of related software products. Variation is a central requirement in this context, as the product line components have to be instantiated, composed, and configured in the context of the products. In many approaches either static composition techniques or dynamic composition techniques based on loose relationships, such as association, aggregation, and replacement of entities, are proposed to design the variation points. If the domain of the product requires runtime variation, however, these approaches do not provide any central management facility for the runtime variation points. As a solution to this problem, we propose a pattern language that provides a domain-specific variation language and runtime variation point management facilities as part of the product line. We present three case studies from the areas of interactive digital television and document archiving in which we have applied this pattern language.

Piecemeal legacy migrating with an architectural pattern language: a case study

Numerous large applications that have evolved over many years are well-functioning and reliable, but have severe problems regarding flexibility and reuse. Due to the many fixes that were applied in a systems lifetime, it is often hard to customize, change or exchange system parts. Therefore, it is problematic to migrate such systems to a more flexible architecture or to new technologies. The document archive/retrieval system, discussed in this article, is an example of a large C system that had such problems. As a solution, we will sketch an architectural pattern language that involves patterns well-suited for a piecemeal migration process. The patterns aim at building and composing highly flexible black-box component architectures with an object-oriented glueing layer. We present a re-engineering case study for the document archive/retrieval system based on these patterns. The patterns are used to wrap the existing C implementations and integrate them with an object system. Moreover, the patterns introduce flexibility hooks into the hot spots of the architecture and let components define their required environment. This enables an easier future evolution of the system. The case study demonstrates a pattern language as an approach for piecemeal legacy migration apart from implementation details.

Using run time traces in automated programming tutoring

Running test cases against a students solution of a programming assignment is one of the easiest ways to generate feedback. If black-box tests are used, students may have difficulties to retrace the complete system behaviour and to find erroneous programming statements. This paper discusses the use of automated trace generation for assisting students in this task. Both manual and automated trace interpretation is discussed and evaluated by examples.

Design for future: managed software evolution

Innovative software engineering methodologies, concepts and tools which focus on supporting the ongoing evolution of complex software, in particular regarding its continuous adaptation to changing functional and quality requirements as well as platforms over a long period are required. Supporting such a co-evolution of software systems along with their environment represents a very challenging undertaking, as it requires a combination or even integration of approaches and insights from different software engineering disciplines. To meet these challenges, the Priority Programme 1593 Design for Future—Managed Software Evolution has been established, funded by the German Research Foundation, to develop fundamental methodologies and a focused approach for long-living software systems, maintaining high quality and supporting evolution during the whole life cycle. The goal of the priority programme is integrated and focused research in software engineering to develop methods for the continuous evolution of software and software/hardware systems for making systems adaptable to changing requirements and environments. For evaluation, we focus on two specific application domains: information systems and production systems in automation engineering. In particular two joint case studies from these application domains promote close collaborations among the individual projects of the priority programme. We consider several research topics that are of common interest, for instance co-evolution of models and implementation code, of models and tests, and among various types of models. Another research topic of common interest are run-time models to automatically synchronise software systems with their abstract models through continuous system monitoring. Both concepts, co-evolution and run-time models contribute to our vision to which we refer to as knowledge carrying software. We consider this as a major need for a long life of such software systems.

Domain-Specific Runtime Variability in Product Line Architectures

A software product line primarily structures the software architecture around the commonalities of a set of products within a specific organization. Common alities can be implemented in prefabricated components, and product differences are typically treated by well-defined variation points that are actualized later on. Dyna mic, domain-specific aspects, such as ad hoc customization by domian experts, are hard to model with static extension techniques. In this paper, we will discuss open issues for dynamic and domain-specific customizations of product line architectures. We will also present an indirection architecture based on Component Wrapper objects and message redirection for dynamically composing and customizing generic components for the use in concrete products. As a case study, we will discuss two designs from a Multimedia Home Platform product line: end-user personalization across different new media platforms and customization of interactive applications by content editors.

ViewPoint-Oriented Software Development: Tool Support for Integrating Multiple Perspectives by Distributed Graph Transformation

Co-operative development of distributed software systems involves to address the multiple perspectives problem: many stakeholders with diverse domain knowledge and differing development strategies collaborate to construct heterogeneous development artifacts using different representation schemes. The ViewPoints framework has been developed for organizing multiple stakeholders, the development processes and notations they use, and the partial specifications they produce. In this contribution we present a tool environment supporting ViewPoint-oriented software development based on a formalization by distributed graph transformation.