AOSD Ontology 1.0 - Public Ontology of Aspect-Orientation

This report presents a Common Foundation for Aspect-Oriented Software Development. A Common Foundation is required to enable effective communication and to enable integration of activities within the Network of Excellence. This Common Foundation is realized by developing an ontology, i.e. the shared meaning of terms and concepts in the domain of AOSD. In the first part of this report, we describe the definitions of an initial set of common AOSD terms. There is general agreement on these definitions. In the second part, we describe the Common Foundation task in detail

Feasibility of EPC to BPEL Model Transformations Based on Ontology and Patterns

Model-Driven Engineering holds the promise of transforming\ud business models into code automatically. This requires the concept of\ud model transformation. In this paper, we assess the feasibility of model\ud transformations from Event-driven Process Chain models to Business\ud Process Execution Language specifications. To this purpose, we use a\ud framework based on ontological analysis and workflow patterns in order\ud to predict the possibilities/limitations of such a model transformation.\ud The framework is validated by evaluating the transformation of several\ud models, including a real-life case.\ud The framework indicates several limitations for transformation. Eleven\ud guidelines and an approach to apply them provide methodological support\ud to improve the feasibility of model transformation from EPC to\ud BPEL

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

SPEEDY: An Eclipse-based IDE for invariant inference

SPEEDY is an Eclipse-based IDE for exploring techniques that assist users in generating correct specifications, particularly including invariant inference algorithms and tools. It integrates with several back-end tools that propose invariants and will incorporate published algorithms for inferring object and loop invariants. Though the architecture is language-neutral, current SPEEDY targets C programs. Building and using SPEEDY has confirmed earlier experience demonstrating the importance of showing and editing specifications in the IDEs that developers customarily use, automating as much of the production and checking of specifications as possible, and showing counterexample information directly in the source code editing environment. As in previous work, automation of specification checking is provided by back-end SMT solvers. However, reducing the effort demanded of software developers using formal methods also requires a GUI design that guides users in writing, reviewing, and correcting specifications and automates specification inference.Comment: In Proceedings F-IDE 2014, arXiv:1404.578

Automated Verification of Design Patterns with LePUS3

Specification and [visual] modelling languages are expected to combine strong abstraction mechanisms with rigour, scalability, and parsimony. LePUS3 is a visual, object-oriented design description language axiomatized in a decidable subset of the first-order predicate logic. We demonstrate how LePUS3 is used to formally specify a structural design pattern and prove (‗verify‘) whether any JavaTM 1.4 program satisfies that specification. We also show how LePUS3 specifications (charts) are composed and how they are verified fully automatically in the Two-Tier Programming Toolkit