Electronic Communications of the EASST (European Association of Software Science and Technology)
Not a member yet
887 research outputs found
Sort by
Modelling Flexible Human Resource Allocation by Stochastic Graph Transformation
Get PDFIn order for business process models to accurately capture the flexibility of human actors, we have to allow for flexible task management and role allocation. That means to take into account deadlines and escalation procedures, consider access rights, but allow temporary promotion and dynamic assignment of actors. In order to meet these requirements we will represent the configurations of a business process as graphs and operations changing these configurations by graph transformation rules. We will propose a domain-specific notation to visualise rules and configurations.
To analyse performance and reliability properties of such models, we use stochastic simulation. The approach is illustrated by means of a pharmacy case study
A Generic Technique for Domain-Specific Visual Language Model Refactoring to Patterns
Get PDFAs the popularity of domain-specific visual languages (DSVLs) grows, concerns have arisen regarding quality assurance and evolvability of their meta-models and model instances. In this paper we address aspects of automated DSVL model instance modification for quality improvement based on refactoring specifications. We propose a graph transformation-based visual language approach for DSVL authors to specify the matching and discovery of DSVL “bad model smells” and the application of pattern-based solutions in a DSVL meta-tool. As an outcome, DSVL users are provided with pattern-based design evolution support as refactorings for their DSVL-based domain models
Search-Based Refactoring using Unfolding of Graph Transformation Systems
No full textTo improve scalability and understandability of search-based refactoring, in this paper, we propose a formulation based on graph transformation which allows us to make use of partial order semantics and an associated analysis technique, the approximated unfolding of graph transformation systems. We use graphs to represent object-oriented software architectures at the class level and graph transformations to describe their refactoring
operations. In the unfolding we can identify dependencies and conflicts between refactoring steps leading to an implicit and therefore more scalable representation of the search space. An optimisation algorithm based on the Ant Colony paradigm is used to explore this search space, aiming to find a sequence of refactoring steps that leads to the best design at a minimal costs
A Survey on Event-B Decomposition
Get PDFModel decomposition is a powerful tool to scale the design of large and complex systems. It enables developers to separate components development from the concerns of their integration and orchestration. Event-B is a refinementbased formal method, equipped with three decomposition styles that come with solid semantic foundations and strong tool support. This paper intends to give some useful insights and modelling guidelines for using these decomposition styles, illustrated by an actual development of a master data updating system
Attribute Computations in the DPoPb Graph Transformation Engine
Get PDFOne of the challenges of attributed graph rewriting systems concerns the implementation of attribute computations. Most of the existing systems adopt the standard algebraic approach where graphs are attributed using sigma-algebras. However, for the sake of efficiency considerations and convenient uses, these systems do not generally implement the whole attribute computations but rely on programs written in a
host language. In previous works we introduced the Double Pushout Pullback (DPoPb) framework which integrates attributed graph rewriting and computation on attributes in a unified categorical approach. This paper discusses the DPoPb’s theoretical and practical advantages when using inductive types and lambda-calculus. We also present an implementation of the DPoPb system in the Haskell language which thoroughly covers the semantics of this graph rewriting system
Compliance between Architecture and Design Models of Component-Based Systems
Get PDFThe design of software systems and the models describing it are usually constrained by the intended software architecture. The intended software architecture defines, for example, how components may be grouped or how they may interact. For the sake of maintenance, evolvability, and smooth operation of software systems, it is of great importance to check and guarantee the architectural compliance of the design and the implementation. Due to size and complexity of modern software systems such checks cannot be done manually but require adequate tool support. Unfortunately, current tool support is not flexible enough to cover easily different aspects of architectural compliance checking.This paper outlines an approach to architectural compliance checking in component-based systems based on logic formalisms. Furthermore, the paper describes a prototypical tool that realizes the approach, and its application in a case study
On the Need of User-defined Libraries in OCL
Get PDFReuse is a fundamental concept of efficient software development. Object-oriented implementation languages offer reuse on different levels of granularity:
method, class, library. While encapsulation of implementation code within methods and classes enables reuse within a project, user-defined libraries are widely used to
share implementation code among different projects.
The specification language OCL offers language concepts like defined attributes and defined operations to enable reuse within a project. However, reuse among different
projects is not possible since OCL does not support the concept of user-defined libraries. There is no standardized way to import user-defined OCL constraints into
another project. In this paper, we argue on the need of a standardized mechanism to make reuse of OCL specifications within a different context possible
Exploring (Meta-)Model Snapshots by Combining Visual and Textual Techniques
Get PDFOne central task in software development by means of graph-based techniques is to inspect and to query the underlying graph. Important issues are, for example, to detect general graph properties like connectivity, to explore more special features like the applicability of left-hand side rules in graph transformations, or to validate snapshots of evolving systems by checking properties in an on-the-fly way. We propose a new approach combining visual and textual techniques for exploring graphs. We emphasize a particular aspect of the underlying graph by showing or hiding nodes and edges. We offer three different ways to explore (meta-)model snapshots which may be combined: (1) selection by object identity and class membership, (2) selection by OCL expression, and (3) selection by path length. One main motivation for our work is to access large or complicated graphs in a systematic way. We evaluate our approach by different middle-sized scenarios. Our evaluation shows that the approach works for large graphs with about 1000 nodes and 2000 edges and for graphs which instantiate metamodels representing software engineering artifacts
Teaching Model Driven Language Handling
Get PDFMany universities teach computer language handling by mainly focussing on compiler theory, although MDD (model-driven development) and meta-modelling are increasingly important in the software industry as well as in computer science. In this article, we share some experiences from teaching a course in computer language handling where the focus is on MDD principles. We discuss the choice of tools and technologies used in demonstrations and exercises, and also give a brief glimpse of a prototype for a simple meta-model-based language handling tool that is currently being designed and considered for future use in teaching