Search

This work aims to estimate the execution time of data processing tasks (specific executions of a program or an algorithm) before their execution. The paper focuses on the estimation of the average-case execution time (ACET). This metric can be used to predict the approximate cost of computations, e.g. when resource consumption in a High-Performance Computing system has to be known in advance. The presented approach proposes to create machine learning models using historical data. The models use program metadata (properties of input data) and parameters of the run-time environment as their explanatory variables. Moreover, the set of these variables can be easily expanded with additional parameters of the specific programs. The program code itself is treated as a black box. The response variable of the model is the execution time. The models have been validated within a Large-Scale Computing system that allows for a unified treatment of programs as computation modules. We present the process of training and validation for several different computation modules and discuss the suitability of the proposed models for ACET estimation in various computing environments.

Requirements definition is the first step in the life cycle of a software system. Requirements are formulated as paragraphs of text and appear ambiguous, so they cannot be translated directly into code. For this reason, they are treated as secondary artifacts for software developers. This paper presents a model-driven based approach where requirements are treated as first-class citizens, and can contribute to the final code. In this approach, requirements are formulated as use case models with their textual scenarios, using a precise requirements language called RSL, allowing an automatic transition to executable Java code. The structure of the generated code follows the Model-View-Presenter (MVP) architectural pattern. The work focuses on the Model layer code, which is responsible for the persistence and storage of data in a database system.

High Performance Computing (HPC) consists in development and execution of sophisticated computation applications, developed by highly skilled IT personnel. Several past studies report significant problems with applying HPC in industry practice. This is caused by lack of necessary IT skills in developing highly parallelised and distributed computation software. This calls for new methods to reduce software development effort when constructing new computation applications. In this paper we propose a generic requirements model consisting of a conceptual domain specification, unified domain vocabulary and use-case-based functional requirements. Vocabulary definition provides detailed clarifications of HPC fundamental component elements and their role in the system. Further we address security issues by providing transparency principles for HPC. We also propose a research agenda that leads to the creation of a model-based software development system dedicated to building Distributed HPC applications at a high level of abstraction, with the object of making HPC more available for smaller institutions.

Use cases are popular means to specify functional requirements in terms of application logic. A typical way to represent this logic is through scenarios expressed using textual or graphical notations. Use case scenarios can be generalised to offer abstract use cases – use case logic patterns. Such patterns capture recurring logic of user-system interactions independent of the particular problem domain. They are composed of abstract use case models and use case scenarios formulated in constrained natural language. Scenarios refer uniformly to an abstract domain model. Use case patterns can be easily instantiated through substituting the abstract domain with a concrete one. In this paper we present a study on application of use case patterns in a real industry project. At first, the project attempted at specifying reoccurring functionality using an ad-hoc approach. This resulted in poor quality specifications as judged by experienced analysts. Following this, we have proposed to use the pattern approach which could be compared with the previous attempt. We have used a library of patterns that were applied through instantiating them in a particular problem domain. Lessons learnt from this comparison show improvement in clarity, repeatability and correctness, regardless of a tooling environment used.

Acceptance testing is highly dependent on the formulation of requirements, as the final system is tested against user requirements. It is thus highly desirable to be able to automate transition from requirements to acceptance tests. In this paper we present a model-driven approach to this issue, where detailed use case models are transformed into test cases. Importantly, our approach facilitates synchronising functional test cases with other types of tests (non-functional, domain logic, user interface) and introducing test data. This leads to a unified approach where requirements models of various kind drive the acceptance testing process. This process is parallel to the development process which also involves automatic transformations from requirements models to software development artefacts (models and code). To show validity of the approach we present a case study which uses a new tool called ReDSeT, that transforms requirements formulated in the Requirements Specification Language (RSL) into tests in a newly proposed Test Specification Language (TSL).

Creation of an unambiguous requirements specification with precise domain vocabulary is crucial for capturing the essence of any software system, either when developing a new system or when recovering knowledge from a legacy one. Software specifications usually maintain noun notions and include them in central vocabularies. Verb or adjective phrases are easily forgotten and their definitions buried inside imprecise paragraphs of text. This paper proposes a model-based language for comprehensive treatment of domain knowledge, expressed through constrained natural language phrases that are grouped by nouns and include verbs, adjectives and prepositions. In this language, vocabularies can be formulated to describe behavioural characteristics of a given problem domain. What is important, these characteristics can be linked from within other specifications similarly to a wiki. The application logic can be formulated through sequences of imperative subject-predicate sentences containing only links to the phrases in the vocabulary. The paper presents an advanced tooling framework to capture application logic specifications making them available for automated transformations down to code. The tools were validated through a controlled experiment.

This chapter presents an approach to software development where model-driven development and software reuse facilities are combined in a natural way. It shows how model transformations building a Platform Independent Model (PIM) can be applied directly to the requirements specified in RSL by domain experts. Further development of the software case (PSM, code) is also supported by transformations, which in addition ensure a rich traceability within the software case. Alternatively, the PSM model and code can also be generated directly from requirements in RSL, thus providing fast development of the final code of at least a system prototype in many situations. The reuse support relies on a similarity-based comparison of requirements for software cases. If a similar part is found in an existing software case, a traceability link-based slice of the solution can be merged into the new case. The implementation of the approach is briefly sketched.

After reading the previous chapters of this book, the reader might wonder how to apply the presented approach in the software engineering practice. It is obvious that in order to use Model-Driven Requirements Engineering, developers will need to update their everyday practices in software development. They will also need to use tools that enable the new and modified practices. In this chapter we present a methodology that provides guidelines in this respect. It encompasses a tool that implements the presented MDRE technology. It also presents necessary modifications to the roles, work products and tasks in a software development project, and especially to standard approaches to requirements engineering. The methodology generally treats the development of new systems, but it is also supplemented with techniques to reuse legacy software and apply patterns to reuse reoccurring behaviour.

Requirements play a pivotal role in software development because they express the needs of the customer. A quality software system can emerge only when the real needs of the client are discovered. However, this is not enough. A typical software development project faces the problem of translating the user needs into a working system. These problems are dealt with by hundreds of books on various aspects of software design and pertaining to the plethora of software development technologies we can choose from. Related activities produce important artefacts that are treated as primary in software development: design models and code. Software design and coding directly contributes to the final system, and thus their results are treated as first-class citizens in the world of software development.

The MOLA transformations presented in the previous chapter were quite elementary and could solve only very simple problems. To fulfil the goal of this book we need to construct a much more sophisticated transformation that operates on the RSL metamodel. This transformation should implement all the rules of RSL semantics presented in Chap. 4. For this purpose, the appropriate MOLA program needs to access RSL models and create UML constructs with embedded textual elements in Java. This means that the MOLA rules in this program should contain various object configurations consistent with the complex RSL and UML metamodels. The RSL models need to be processed (“parsed”) in compliance with their runtime semantics and the generated code should be compatible with many detailed aspects of a specific implementation technology. All these issues result in very significant complexity of necessary MOLA code. To assure manageability and comprehension, this code should be properly organised, using typical approaches of structural programming.

The previous chapter explained the rules for transforming models of one kind (written in RSL) to models of another kind (written in UML), and code. In order to implement these rules, we need to write transformation programs. For this purpose, we could use any programming language assuming we can access the model repository and traverse through the source models and create the target models. However, writing a Java program for the purpose of model transformation would then become a quite laborious task due to the lack of necessary constructs to represent model elements that form sophisticated graphs. Thus, instead of a typical programming language, we use a dedicated model transformation language.

The key to any modelling activity is a modelling language. For a model-driven approach that involves model transformations, we need to define this language precisely. Here, we present such language specific for requirements modelling, called the Requirements Specification Language (RSL). In the previous chapter, we have given some glimpses of its syntax and semantics and in this chapter we present it in detail.

Developing a new software system based on legacy software is a labor-intensive process. The main problem lies in preserving the application and domain (business) logic. This paper presents an approach to automate the process of extracting this logic, together with accompanying domain definitions. The approach is based on recording and processing the legacy system behaviour, observable through its user interface. The recovered application logic is represented with use case scenarios having precise sentences describing user-system interactions. These scenarios are tightly linked with domain models which are also created. The presented approach is supported by a tool chain. The central idea is to use a standard test automation system to capture test scripts. These scripts are then processed by a dedicated translation tool and translated into constrained natural language models. These models are machine processable, which allows for further automatic transformations even down to code. The paper presents the results of a case study where the approach and tools were used to migrate an old desktop system to a modern web technology application.

Software modeling is an increasingly popular method among software development teams to overcome the problems associated with complexity of contemporary software systems. It can be argued that teaching modeling to software engineers is as important as teaching maths and physics to general engineers. This lead many academic and industrial centers to introducing modeling courses to their curricula. Unfortunately, it seems that education does not yet support the modeling paradigm well enough, thus limiting its acceptance as a mature method of developing software systems. This symposium sought for innovations on teaching modeling that would show its benefits in attractive and pedagogically effective ways. Three areas that need improvement were identified: placing modeling in the software engineering curriculum, teaching model semantics, and tool support for teaching modeling. Several pedagogical solutions in these three areas were presented. The symposium concluded with several recommendations on such improvements, with the most important being: "let the students play with models".

Model-driven engineering is becoming increasingly popular in software development projects as it raises level of abstraction, thus improving our ability to handle complex systems. In many academic and industrial centers, software modeling has already been introduced into their curricula. Despite this, it seems that education does not yet support the modeling paradigm well enough thus limiting its acceptance as a mature method of developing software systems. The goal of this symposium was to find ways to change this situation. Specifically, the symposium sought ways of showing benefits of modeling in a way that is pedagogically effective and attractive to the students. It also tried to make recommendations for placing the modeling courses in the overall software development educational path, which should include not only UML fundamentals but also a demonstration of the importance and place of modeling in the overall path from business (environment) to software products.

The paper introduces two concepts based on use cases: business patterns and automation patterns. It describes a connection between the business and automation patterns with classes. Finally, it presents an idea of a multi-level library that allows global reuse of software development models and code.

Transformations of models on the Computation Independent level of the MDA framework seem to have little focus in the current research. This is despite their great significance for ensuring traceability of business requirements into system design and implementation. Hence, this paper proposes a suite of profiles that define appropriate models and transformations between them. There is briefly described a set of well-formedness rules for the models, and a set of mappings and rules that allow for model transformations. These mappings and rules are presented in the context of UML 2.0 Profiles.

Scenario based notations are becoming more and more popular as means for user requirements elicitation. They can be used in more formal specifications as part of detailed use case templates or in agile processes to capture informal user stories. Despite their significance in software engineering, scenarios seem not to be properly supported by appropriate tools. This paper describes a scenario construction tool that offers clear separation of the actual story from notions used therein. The tool is constructed as an extension to visual notation of UML's use cases. It is based on an extended UML metamodel in the area of activities and classifiers. This formal basis makes the tool capable of supplying the existing UML tools with an additional layer of requirements models based on scenarios and notions. This layer makes it possible to transform requirements directly into design-level models. The tool offers such transformation capabilities based on a simple model mapping. This transformation supports human efforts to keep the system's design consistent with the user's needs expressed through scenarios.

Use cases have achieved wide use as specification tools for systems observable behavior, but there still remains a large gap between specifying behavior and determining the software components to build or procure. WUsCaM 05 – “Workshop on Use Cases in Model-Driven Software Engineering” – brought together use case and MDSE experts from industry and academia to identify and characterize problem areas and promising approaches.

Writing good user stories for software systems seems to be a hard task. Story writers often tend to mix real stories (sequences of events) with descriptions of the domain (notion definitions). This often leads to inconsistencies and confusion in communication between the users and the developers. This paper proposes a tool that could support writing coherent user stories. The tool clearly separates the domain notion definitions from the actual stories. This leads to a consistent requirements model that is more readable by the users and also easier to implement by the developers.

International audience; Abstract. While increasing progressively its expressive power, UML has become more and more difficult to read and understand, especially for beginners. To teach the whole UML is not possible, therefore teachers only deal with a subset of UML. We present a framework for defining precisely a consistent subset of a language, allowing everybody to define his/her own subset. An extended example shows a way to simplify UML sequence diagrams. Our approach use standard UML tools; models in the simplified language are fully compatible with UML; model mapping between metamodels is done automatically from specifications based on marking with stereotypes; constraints are automatically translated from the simplified language to UML.