Alexandre L. Correa

Applying Refactoring Techniques to UML/OCL Models

The Object Constraint Language (OCL) plays an important role in the elaboration of precise UML models. Although OCL was designed to be both formal and simple, UML/OCL models may be difficult to understand and evolve, particularly when constraints containing complex or duplicate expressions are present. Moreover, the evaluation of how changes in the definition of the underlying classes impact the OCL part of a model may be a difficult and time-consuming task. In this paper, we discuss how refactoring techniques can be applied in order to improve the understandability of a UML/OCL model and how to support its evolution. In particular, we present a collection of refactorings and discuss how they can be specified and automated. We also show how the model animation features can be used to increase our confidence that the semantics of a model is preserved when a refactoring is manually performed.

Object Oriented Design Expertise Reuse: An Approach Based on Heuristics, Design Patterns and Anti-patterns

Object Oriented (OO) languages do not guarantee that a system is flexible enough to absorb future requirements, nor that its components can be reused in other contexts. This paper presents an approach to OO design expertise reuse, which is able to detect certain constructions that compromise future expansion or modification of OO systems, and suggest their replacement by more adequate ones. Both reengineering legacy systems, and systems that are still under development are considered by the approach. A tool (OOPDTool) was developed to support the approach, comprising a knowledge base of good design constructions, that correspond to heuristics and design patterns, as well as problematic constructions (i.e., anti-patterns).

Refactoring object constraint language specifications

The object constraint language (OCL) plays an important role in the elaboration of precise models. Although OCL was designed to be both formal and simple, OCL specifications may be difficult to understand and evolve, particularly those containing complex or duplicated expressions. In this paper, we discuss how refactoring techniques can be applied in order to improve the understandability and maintainability of OCL specifications. In particular, we present several potentially bad constructions often found in OCL specifications and a collection of refactorings that can be applied to replace such constructions by better ones. We also briefly discuss how refactorings can be automated and how model regression testing can be used to increase our confidence that the semantics of an OCL specification has been preserved after manually performed refactorings.

Elaboration of use case specifications: an approach based on use case fragments

Use case description has gained a wide acceptance among the many techniques available for information systems requirements specification. However, piecing up all the details required for the production of a high quality use case can be a daunting task, especially for students and novice requirements professionals. This paper presents an approach aiming at reducing the time required for the elaboration of high quality use case specifications. The basis of the approach is to write a use case text using the composition of set of pre-defined fragments, where each fragment represents a recurring set of interactions required to achieve a sub-goal. Each fragment can then be customized to meet use case goals. Since each fragment is coded using the best practices for writing use case steps, both the fragment text and the final use case text will be well composed. We believe that this approach will allow novice requirements professional to write high quality use cases in less time than it would be necessary using the other approaches. Our experience on writing use cases for business information systems using a catalogue of use case fragments suggested that they can be a facilitator in several aspects, not only improving the writing speed, but also leading to standardization and concision of use case specifications.

Tool support for OCL and related formalisms – needs and trends

The recent trend in software engineering to model-centered methodologies is an excellent opportunity for OCL to become a widely used specification language. If the focus of the development activities is shifted from implementation code to more abstract models then software developers need a formalism to provide a complete, unambiguous and consistent model at a very detailed level. OCL is currently the only language that can bring this level of detail to UML models. The purpose of the workshop was to identify future challenges for OCL and to discuss how OCL and its current tool support can be improved to meet these challenges. The workshop gathered numerous experts from academia and industry to report on success stories, to formulate wishes to the next generation of OCL tools, and to identify weaknesses in the language, which make OCL sometimes cumbersome to use. The workshop could also attract numerous people whose aim was to get an overview on the state of the art of OCL tool support and on how OCL can efficiently be applied in practice.

An empirical study of the impact of OCL smells and refactorings on the understandability of OCL specifications

The Object Constraint Language (OCL) is a OMG standard that plays an important role in the elaboration of precise models. However, it is not hard to find models and metamodels containing overly complex OCL expressions. Refactoring is a technique that can be used in this context since its goal is to reduce complexity by incrementally improving the internal software quality. Indeed several refactorings have already been proposed to improve the quality of OCL expressions. This paper presents the results of an empirical study that investigates the impact of poor OCL constructs, also known as OCL Smells, and OCL refactorings on the understandability of OCL expressions. Current results show that most refactorings significantly improve the understandability of OCL specifications.

A method for validating the compliance of business processes to business rules

Regulatory compliance of business operations and practices is increasingly becoming an area of great concern for management, costing tens of billions of dollars in compliance actions a year. This paper presents a method for validating business processes with respect to the business rules. In the proposed method, business processes are modeled with UML activity diagrams, whilst business rules are represented as OCL expressions attached to process activities and the business conceptual model. The model validation is based on the simulation of the execution of process instances based on specific scenarios. The simulation algorithm steps through the process model executing the actions associated to the activities with the help of the USE tool and checking for violations of the associated business rules. The proposed method allows the modeler to have an early feedback of possible defects that may exist in a business process model.

Refactoring to improve the understandability of specifications written in object constraint language

Object constraint language (OCL) is the object management group standard language for the precise specification of constraints associated with MetaObject facility specification-compliant models and metamodels. Although OCL has been created with the intention of being a simpler language when compared with traditional formal specification languages, it is common to find specifications containing OCL constraints that are difficult to understand and evolve. A set of potential problematic constructions often found in specifications written in OCL and a set of refactorings that can be applied to remove them are presented. We present an experimental study that has been performed to evaluate the effects of applying those strategies on the understandability of OCL specifications. The approach to provide automated support for OCL refactorings is also discussed.

Precise specification and validation of transactional business software

This work presents an approach to the specification and validation of transactional business software. The focus of this work is on the production of detailed use case specifications and on the precise definition of all transactions and business rules using a subset of UML diagrams combined with textual specifications written in OCL (Object Constraint Language). We show how to produce and validate such artifacts using a scenario driven approach combined with animation and prototyping techniques in a highly iterative process. The paper also presents PSW (Precise Specification Workbench), a tool that supports the proposed approach.

Automatic Spreadsheet Generation from Conceptual Models

The flexibility and ease-of-use of spreadsheets allow users with little CS background to build computational solutions to solve their problems. However, inexperienced users may build erroneous spreadsheets. Modeling is commonly used in software development to allow users to visualize, communicate, and validate different aspects of a system before starting its construction. This work proposes a Model-Driven Engineering (MDE) approach that automatically generates spreadsheets from conceptual models aiming to reduce the number of errors introduced by users while using spreadsheets. Initially, we designed and executed an empirical study to identify the most common errors users commit when developing spreadsheets. The results of this study have shown that even users who classify themselves as experienced spreadsheet developers commit a large number of errors while developing a spreadsheet. Also, it has shown that formula-related errors are the most common errors introduced by users (55%). A second study involved humans using a spreadsheet generated by our approach and showed initial evidence that the approach can build spreadsheets that avoid the introduction of several types of errors often present in spreadsheets manually created by users. In this sense, we observed 98% correct answers to 234 questions involving spreadsheet manipulation.