Matheus Carvalho Viana

Domain-Specific Modeling Languages to improve framework instantiation

Frameworks are reusable software composed of concrete and abstract classes that implement the functionality of a domain. Applications reuse frameworks to enhance quality and development efficiency. However, frameworks are hard to learn and reuse. Application developers must understand the complex class hierarchy of the framework to instantiate it properly. In this paper, we present an approach to build a Domain-Specific Modeling Language (DSML) of a framework and use it to facilitate framework reuse during application development. The DSML of a framework is built by identifying the features of this framework and the information required to instantiate them. Application generators transform models created with the DSML into application code, hiding framework complexities. In this paper, we illustrate the use of our approach in a framework for the domain of business resource transactions and a experiment that evaluated the efficiency obtained with our approach.

Improving the structure of KDM instances via refactorings: An experimental study using KDM-RE

Architecture-Driven Modernization (ADM) is an initiative of the Object Management Group (OMG) whose main purpose is to provide standard metamodels for software modernization activities. The most important metamodel is the Knowledge Discovery Metamodel (KDM), which represents software artifacts in a language-agnostic fashion. A fundamental step in software modernization is refactoring. However, there is a lack of tools that address how refactoring can be applied in conjunction with ADM. We developed a tool, called KDM-RE, that supports refactorings in KDM instances through: (i) a set of wizards that aid the software modernization engineer during refactoring activities; (ii) a change propagation module that keeps the internal metamodels synchronized; and (iii) the selection and application of refactorings available in its repository. This paper evaluates the application of refactorings to KDM instances in an experiment involving seven systems implemented in Java. We compared the pre-refactoring versions of these systems with the refactored ones using the Quality Model for Object-Oriented Design (QMOOD) metric set. The results from this evaluation suggest that KDM-RE provides advantages to software modernization engineers refactoring systems represented as KDMs.

F3T: a tool to support the F3 approach on the development and reuse of frameworks

BackgroundFrameworks are used to enhance the quality of applications and the productivity of the development process, since applications may be designed and implemented by reusing framework classes. However, frameworks are hard to develop, learn and reuse, due to their adaptive nature. From Feature to Frameworks (F3) is an approach that supports framework development in two steps: Domain Modeling, to model domain features of the framework; and Framework Construction, to develop framework source-code based on the modeled domain and on patterns provided by this approach.MethodsIn this article, it is presented the From Features to Framework Tool (F3T), which supports the use of the F3 approach on framework development.ResultsThis tool provides an editor for domain modeling and generates framework source-code according to the patterns of the F3 approach. In addition, F3T also generates a Domain-Specific Modeling Language that allows the modeling of applications and the generation of their source-code. F3T has been evaluated in two experiments and the results are presented in this article.ConclusionsF3T facilitates framework development and reuse by omitting implementation complexities and performing code generation.

Developing Frameworks from Extended Feature Models

Frameworks are composed of concrete and abstract classes implementing the functionality of a domain. Applications can reuse framework design and code to improve their quality and be developed more efficiently. However, framework development is a complex task, since it must be adaptable enough to be reused by several applications. In this chapter we present the From Features to Framework (F3) approach, which aims to facilitate the development of frameworks. This approach is divided in two steps: Domain Modeling, in which framework domain is defined in a extended feature model; and Framework Construction, in which the framework is designed and implemented by following a set of patterns from its feature model. Since these steps can be systematically applied, we also present the design of a tool that supports the use of the F3 approach on framework development. Moreover, we performed an experiment that showed that the F3 approach makes framework development easier and more efficient.

Reengineering of Object-Oriented Software into Aspect-Oriented Ones Supported by Class Models

Object-Oriented Software Reengineering (OO) into Aspect-Oriented Software (AO) is a challenging task, mainly when it is done by means of refactorings in the code-level. The reason is that direct transformation from OO code to AO one needs of several design decisions due to differences of both paradigms. To make this transformation more controlled and systematic, we propose the use of concern-based refactorings, supported by class models. It allows design decisions to be made during the reengineering process, improving the quality of the final models. An example is presented to assess the applicability of the proposed refactorings. Moreover, we also present a case study, in which AO class models created based on the refactorings are compared with another obtained without the aid of them. The data obtained indicated that the use of the proposed refactorings improved the efficacy and productivity of maintenance groups during the process of software reengineering.

An approach to develop frameworks from feature models

Frameworks are reusable software composed of concrete and abstract classes that implement the functionality of a domain. Applications can reuse framework design and code in order to improve their quality and be developed more efficiently. However, to develop software for reuse, such as a framework, is harder than to develop an application. Hence, in this paper we present an approach, named From Features to Framework (F3), to facilitate the development of white box frameworks. This approach is divided in two steps: Domain Modeling, in which the features of the framework are defined; and Framework Construction, in which the framework is designed and implemented according to its features and their relationships. We also present an experiment that evaluated the F3 approach showing that it makes framework development easier and more efficient.

F3T: From Features to Frameworks Tool

Frameworks are used to enhance the quality of applications and the productivity of development process, since applications can be designed and implemented by reusing framework classes. However, frameworks are hard to develop, learn and reuse, due to their adaptive nature. In this paper we present the From Features to Framework Tool (F3T), which supports framework development in two steps: Domain Modeling, in which the features of the framework domain are modeled, and Framework Construction, in which the source-code and the Domain-Specific Modeling Language (DSML) of the framework are generated from the features. In addition, the F3T also supports the use of the framework DSML to model applications and generate their source-code. The F3T has been evaluated in a experiment that is also presented in this paper.

Building Domain-Specific Modeling Languages for Frameworks

Frameworks support application development improving productivity and quality. However, due to the number of hot stops to configure them, reusing frameworks may be a complex task which can make developers misuse them and insert defects in the application code. In order to reduce the complexity of this task, we propose increase its abstraction level by using Domain-Specific Modeling Languages (DSML) based on framework features to model and to generate applications that reuse these frameworks. In our approach, framework features and their hot spots are identified from an analysis of its source code and documentation, and then a DSML and a set of templates are constructed. With this DSML, applications reusing the framework can be modeled and generated, protecting developers from framework complexity and decreasing the time spent on the implementation. We illustrate our approach using GRENJ framework as example.