Markus Luckey

Adapt cases: extending use cases for adaptive systems

Adaptivity is prevalent in todays software. Mobile devices self-adapt to available network connections, washing machines adapt to the amount of laundry, etc. Current approaches for engineering such systems facilitate the specification of adaptivity in the analysis and the technical design. However, the modeling of platform independent models for adaptivity in the logical design phase remains rather neglected causing a gap between the analysis and the technical design phase. To overcome this situation, we propose an approach called Adapt Cases. Adapt Cases allow the explicit modeling of adaptivity with domain-specific means, enabling adaptivity to gather attention early in the software engineering process. Since our approach is based on the concept of use cases it is easy adoptable in new and even running projects that use the UML as a specification language, and additionally, can be easily incorporated into model-based development environments.

Detection of Semantically Equivalent Fragments for Business Process Model Change Management

Modern business process modeling environments support distributed development by means of model version control, i.e., comparison and merging of two different model versions. This is a challenging task since most modeling languages support an almost arbitrary creation of process models. Thus, in multi-developer environments, process models or parts of them are often syntactically very different but semantically equivalent. Hence, the comparison of business process models must be performed on a semantic level rather then on a syntactic level. For the domain of business process modeling, this problem is yet unsolved. This paper describes an approach that allows the semantic comparison of different business process models using a normal form. For that purpose, the process models are fully automatically translated into process model terms and normalized using a term rewriting system. The resulting normal forms can be efficiently compared and easily be used for reconciliation. Our approach enables the semantic comparison of business process models ignoring syntactic redundancies.

Performance analysis of self-adaptive systems for requirements validation at design-time

Self-adaptation allows continuously running software systems to operate in changing and uncertain contexts while meeting their requirements in a broad range of contexts, e.g., from low to high load situations. As a consequence, requirements for self-adaptive systems are more complex than requirements for static systems as they have to explicitly address properties of the self-adaptation layer. While approaches exist in the literature to capture this new type of requirements formally, their achievement cannot be analyzed in early design phases yet. In this paper, we apply RELAX to formally specify non-functional requirements for self-adaptive systems. We then apply our model-based SimuLizar approach for a semi-automatic analysis to test whether the self-adaptation layer ensures that these non-functional requirements are met. We evaluate our approach on the design of a proof-of-concept load balancer system. As this evaluation demonstrates, we can iteratively improve our system design by improving unsatisfactory self-adaption rules.

Precise detection of conflicting change operations using process model terms

Version management of process models requires that changes can be resolved by applying change operations. Conflict detection is an important part of version management and the minimization of the number of detected conflicts also reduces the overhead when resolving changes. As not every syntactic conflict leads to a conflict when taking into account model semantics, a computation of conflicts solely on the syntax leads to an unnecessary high number of conflicts. In this paper, we introduce the notion of syntactic and semantic conflicts for change operations of process models. We provide a method how to efficiently compute conflicts, using a term formalization of process models. Using this approach, we can significantly reduce the number of overall conflicts and thereby reduce the amount of work for the user when resolving conflicts.

Model-driven performance engineering of self-adaptive systems: a survey

To meet quality-of-service requirements in changing environments, modern software systems adapt themselves. The structure, and correspondingly the behavior, of these systems undergoes continuous change. Model-driven performance engineering, however, assumes static system structures, behavior, and deployment. Hence, self-adaptive systems pose new challenges to model-driven performance engineering. There are a few surveys on self-adaptive systems, performance engineering, and the combination of both in the literature. In contrast to existing work, here we focus on model-driven performance analysis approaches. Based on a systematic literature review, we present a classification, identify open issues, and outline further research.

Detection and resolution of conflicting change operations in version management of process models

Version management of process models requires that different versions of process models are integrated by applying change operations. Conflict detection between individually applied change operations and conflict resolution support are integral parts of version management. For conflict detection it is utterly important to compute a precise set of conflicts, since the minimization of the number of detected conflicts also reduces the overhead for merging different process model versions. As not every syntactic conflict leads to a conflict when taking into account model semantics, a computation of conflicts solely on the syntax leads to an unnecessary high number of conflicts. Moreover, even the set of precisely computed conflicts can be extensive and their resolution means a significant workload for a user. As a consequence, adequate support is required that guides a user through the resolution process and suggests possible resolution strategies for individual conflicts. In this paper, we introduce the notion of syntactic and semantic conflicts for change operations of process models. We provide a method how to efficiently compute conflicts precisely, using a term formalization of process models and consider the subsequent resolution of the detected conflicts based on different strategies. Using this approach, we can significantly reduce the number of overall conflicts and reduce the amount of work for the user when resolving conflicts.

Reusing security requirements using an extended quality model

A reoccurring problem in software engineering constitutes ensuring sufficient completeness of requirements specifications with economically justifiable efforts. Formulating precise quality requirements and especially security requirements is elaborate as they depend on many stakeholders and technological aspects that are often unclear in early project phases. Threats that may have a severe impact on the software product are sometimes not even known. One approach to tackle this situation is reusing quality requirements, because they are to a high degree similar in different software products. The effect can be higher quality while at the same time saving time and budget. Quality models are a way to explicitly specify quality. Based on activity-based quality models an approach for specifying reusable quality requirements in early project phases is proposed that also allows a direct derivation of suitable quality requirements for new projects. The applicability of this approach and the resulting reuse potential is investigated in a case study, which concentrates on the security requirements of six industrial projects.

SheetDiff: A Tool for Identifying Changes in Spreadsheets

Most spreadsheets, like other software, change over time. A frequently occurring scenario is the repeated reuse and adaptation of spreadsheets from one project to another. If several versions of one spreadsheet for grading/ budgeting/etc. have accumulated, it is often not obvious which one to choose for the next project. In situations like these, an understanding of how two versions of a spreadsheet differ is crucial to make an informed choice. Other scenarios are the reconciliation of two spreadsheets created by different users, generalizing different spreadsheets into a common template, or simply understanding and documenting the evolution of a spreadsheet over time. In this paper we present a method for identifying the changes between two spreadsheets with the explicit goal of presenting them to users in a concise form. We have implemented a prototype system, called SheetDiff, and tested the approach on several different spreadsheet pairs. As our evaluations will show, this system works reliably in practice. Moreover, we have compared SheetDiff to similar systems that are commercially available. An important difference is that while all these other tools distribute the change representation over two spreadsheets, our system displays all changes in the context of one spreadsheet, which results in a more compact representation.

Systematic evolution of model-based spreadsheet applications

Using spreadsheets is the preferred method to calculate, display or store anything that fits into a table-like structure. They are often used by end users to create applications, although they have one critical drawback-spreadsheets are very error-prone. Recent research has developed methods to reduce this error-proneness by introducing a new way of object-oriented modeling of spreadsheets before using them. These spreadsheet models, termed ClassSheets, are used to generate concrete spreadsheets on the instance level. By this approach sources of errors are reduced and spreadsheet applications become easier to understand. As usual for almost every other application, requirements on spreadsheets change due to the changing environment. Thus, the problem of evolution of spreadsheets arises. The update and evolution of spreadsheets is the uttermost source of errors that may have severe impact. In this paper, we will introduce a model-based approach to spreadsheet evolution by propagating updates on spreadsheet models (i.e. ClassSheets) to spreadsheets. To this end, update commands for the ClassSheet layer are automatically transformed to those for the spreadsheet layer. We describe spreadsheet model update propagation using a formal framework and present an integrated tool suite that allows the easy creation and safe update of spreadsheet models. The presented approach greatly contributes to the problem of software evolution and maintenance for spreadsheets and thus avoids many errors that might have severe impacts.

QUAASY: QUality Assurance of Adaptive SYstems

The emerging approach to tackle the increasing complexity of todays software systems is the use of self-adaptation techniques. Modeling and implementing adaptivity features is a burdensome and error-prone task that potentially results in erroneous system models. As a consequence, quality analysis and assurance must be considered early in the development of self-adaptive systems. We propose a quality assurance approach for self-adaptive systems in terms of an integrated modeling and analysis approach, which helps identifying errors in modeled self-adaptive systems early in the design process. We employ a modeling language for self-adaptive systems including adaptation rules and formally define their semantics. Given the language and its formal semantics, we formulate quality properties, such as fairness of the specified adaptation rule system. These quality properties are verified using a model checking approach.