Michal Smialek

Case-based Reuse with Partial Requirements Specifications

A case-based approach allows reuse without the usual and significant effort for making software explicitly reusable. We even support such reuse for only partially developed requirements, since it allows reuse already without the need to develop a “complete” specification first. The solution information (models and code) of (one of) the most similar problems can then be taken for reuse and adapted to the newly specified requirements. And even the specification of these new requirements can be facilitated, since the retrieved software case contains related requirements, which may be reused as well.

Translation of use case scenarios to Java code

Use cases are usually treated as second class citizens in the software development chain based on models. Their textual descriptions (scenarios) are treated as informal input to more formal design models that can then be (semi- )automatically transformed down to code. In this paper we will show that use case scenarios can gain precise metamodel-based notation and semantics enabling automatic processing. What is more, we will show transformation algorithms that can transform use case scenarios directly to dynamic code in Java. The presented transformation can generate the full structure of the system following the MVP architectural pattern, including complete method contents for the application logic (Presenter) and presentation (View) layers. It also provides a code skeleton for the domain logic (Model) layer. The use case notation and the transformation were implemented within a sophisticated tool suite. Based on this, the paper discusses the evaluation efforts based on a case study.

From use cases and their relationships to code

Use cases are used in many methodologies to drive the software engineering process. Though, their transition to code was usually a mostly manual process. In the context of MDD, use cases gain attention as first-class artifacts with representation notations allowing for automatic transformations to analysis and design models. The paper concentrates on an important problem of constructing transformations that cater for use case relationships. It presents a notation that unifies the ambiguous “include” and “extend”, and allows for representing them within textual use case scenarios. This notation, equipped with runtime semantics, is used to construct a direct transformation into working code. The code is placed within method bodies of the Controller/Presenter and View layers within the MVC/MVP framework. Based on this transformation, an agile use-case-driven development process is possible.

Facilitating transition from requirements to code with the ReDSeeDS tool

This paper presents a tool suite that automates transition from precise use case and domain models to code. The suite is built around the Requirements Specification Language (RSL) that is based on a precise constrained language grammar. RSL specifications can be used to generate complete MVC/MVP code structure together with method bodies of the Controller layer.

Runtime semantics of use case stories

Direct end-user participation in software system construction necessitates bringing general-purpose programming activities to the level understandable by “laymen”. This paper introduces a new software development approach where stories written in commonly understood structured natural language gain runtime semantics. Stories are precisely linked to domain concepts and actions, thus forming the application logic of the system. These constructs are written at a high level of abstraction, very close to detailed software requirements specifications. In fact, they are structured into familiar use case models that include special “invocation” relationships between use cases. At the same time, the paper proposes precise translational semantics for such defined stories. For each story element, equivalent Java code is derived. This semantics has been implemented within a tool containing a story editor and a code generator producing fully dynamic application logic code with Swing-based user interface. Ease of use of the new story language and usefulness of the generated Java code has been evaluated through student assignment projects.

Reusing Terminology for Requirements Specifications from WordNet

In order to make requirements comprehensible to humans and as unambiguous as possible, a glossary and/or domain model is needed for defining the terminology used. Unless these are available from related projects, however,they are hard to create. Therefore, we propose to reuse terminology and its definition for requirements specifications from the semantic lexicon WordNet. For making this useful, however, we had to deal with the issue of disambiguation of the general terminology there for a given domain of a requirements specification.

RECOVERY AND MIGRATION OF APPLICATION LOGIC FROM LEGACY SYSTEMS

Future Internet technologies necessitate dramatic changes in system design, delivery and usage patterns. For many legacy applications it means that their further development and transition to the Internet becomes problematic or even impossible due to the obsolescence of technologies they use. Replacement of the old system with the new one, built from scratch, is usually economically unacceptable. Therefore, there is a call for methods and tools supporting the automated migration of legacy systems into a new paradigm. This paper proposes a tool supported method for recovery and migration of application logic information from legacy systems. The information extracted from a legacy application is stored in the form of precise requirement-level models enabling automated transformation into a new system structure in a model-driven way. Evaluation of the approach is based on a case study legacy system.

Automating acceptance testing with tool support

During acceptance testing different areas of delivered software system are reviewed. Usually these are functionality, business domain logic, non-functional characteristics, user interface. Although they are related to the same particular functional area, they are verified separately. This paper presents the concept and the Requirements Driven Software Testing (ReDSeT) tool, which allows for automatic integrated test generation based on different types of requirements. Tests are expressed in newly introduced Test Specification Language (TSL). The basis for functional test generation are detailed use case models. Furthermore, by combining different types of requirements, relations between tests are created. The constructed tool acknowledges validity of the presented concept.

Generating Graphical User Interfaces from Precise Domain Specifications

Turning requirements into working systems is the essence of software engineering. This paper proposes automation of one of the aspects of this vast problem: generating user interfaces directly from requirements models. It presents syntax and semantics of a comprehensible yet precise domain specification language. For this language, the paper presents the process of generating code for the user interface elements. This includes model transformation procedures to generate window initiation code and event handlers associated with these windows. The process is illustrated with an example based on an actual system developed using the presented approach.