Während Softwareproduktlinien auf die Entwicklung von Softwarevarianten innerhalb einer Organisation zielen und einen längst etablierten Softwareentwicklungsansatz darstellen, wendet sich aktuell das Augenmerk verstärkt Software-Ökosystemen zu.
In diesem Entwicklungsmodell gibt es keine zentrale Koordination und die Eigenschaften des Systems werden erst zur Laufzeit beim Endanwender bestimmt.
Dies bringt eine Vielzahl neuer wissenschaftlicher und technischer Herausforderungen mit sich, die in diesem Vortrag dargestellt werden.
In meiner Arbeitsgruppe Software Systems Engineering an der Universität Hildesheim wurde ein Ansatz geschaffen, um die Entwicklung von Softwareproduktlinien und Software-Ökosystemen zu unterstützen. Grundlage dafür ist ein umfassender und flexibler Ansatz zur Unterstützung von Variabilität, sowie darauf aufbauend ein flexibler Ansatz zur effizienten Ableitung von Produktlinieninstanzen. Die Produktableitung wird dabei als (Modell-)transformations¬problem betrachtet.
In diesem Vortrag möchte ich insbesondere auf die besonderen Schwierigkeiten von Software-Ökosystemen eingehen, die über die üblichen Herausforderungen von Softwareproduktlinien hinausgehen. Hierzu zählen der Umgang mit Offenheit der Variation und als Konsequenz die Schwierigkeit die Vollständigkeit der Konfiguration und die Konsistenz und Vollständigkeit der Implementierung zu gewährleisten.

Qualitativ mangelhafte Softwaresysteme wie jüngst die Steuerungssoftware der Boeing 747-8 geraten immer wieder in die Schlagzeilen. Wie weit Softwaremetriken bei der Erkennung solcher Probleme helfen können, ist noch weitgehend ungeklärt. In diesem Vortrag werde ich jüngste Forschungsergebnisse nach denen Refactorings Metrikmesswerte oftmals negativ beeinflussen, diskutieren und zeigen, wie Kombinationen von Metriken und Code-Analyse zur Erkennung von “Design-Smells“ verwendet werden können. Abschließend werde ich skizzieren, wie ich zukünftig die Abschätzung von Änderungsaufwänden mit Hilfe von Metriken verbessern möchte.

Software systems, like many other systems, need to change in order to stay successful on the market. As has been described by Lehman’s Laws of Software Evolution, these changes cause software systems to become larger in size and more complex. As a consequence, more resources are needed to maintain, or in general, evolve a software system. Evolving software systems is therefore mastering change and system complexity. In this presentation, I show how the various data recorded for software projects can be used to identify critical parts of a software system and to help steering the evolution of software systems. Furthermore, I show how visualization techniques can be used to help software engineers to comprehend the implementation of large, complex software systems including large spreadsheets.

Research on automated software engineering aims to improve software development by automating tedious or error prone manual activities. We can now automatically produce tests, models, patches – and even software itself. But can we ultimately remove the human from software engineering, and is this even desirable? In this talk, I exemplify in the domain of automated software testing that software engineering depends on human software engineers, and discuss implications this has on automation research. Automated techniques need to be developed for software engineers, not to replace them. We can, however, utilise both, explicit and implicit human intelligence, to take automated software engineering to the next level.

Cyperphysical systems (CPS) are on the horizon to challenge the way we see and develop computer systems. CPS provide the integration of embedded computing, real-time computing, distributed computing, parallel computing, mobile computing, and server systems, resulting in completely new application domains. On one side the arise of CPS is just the natural consequence of various incremental improvements of enabling technologies. But from the software engineering side it creates big challenges for software engineering. CPS will result in significant rise of system complexities. At the same time there are serious security and safety challenges as it requires to combine subsystems with closed-world assumptions and those with open-world assumptions, requiring new interfacing solutions. In this talk we present the research towards the development of a programming model that is aimed to withstand the CPS challenge. This programming model will provide support for mixed-criticality systems and adaptability. As a fundamental change in software engineering we present a computing model that unifies the non-real time, soft-real time and hard real-time paradigms. An important mechanism included in this computing model are tolerance ranges, which allow to adapt the system when necessary. Such adaptation scenarios include fault-tolerance with reconfiguration and optimisation of resources like processing time or power consumption.