Eduardo Martins Guerra

Refactoring Test Code Safely

Test driven development is a technique in which the refactoring occurs all the time, in the application code and in the test code. But there is not a method to guarantee that the test code behavior after one refactoring remains unchanged. This paper presents a representation based on the JUnit unit test structure, as well as a classification of test code refactorings that may ease the analysis to verify if the test code refactoring was carried out safely, i.e., if the observable behavior of the refactored test code has been kept unchanged. The use of this proposed technique may safely improve and speed up the production of test code refactorings.

A pattern language for metadata-based frameworks

Metadata-based frameworks are those that process their logic based on the metadata of the classes whose instances they are working with. Many recent frameworks use this to get a higher reuse level and to be more suitably adapted to the application needs. However, there is not yet a complete best practices documentation or reference architecture for the development of frameworks by using the metadata approach. As a result, this paper presents a pattern language that addresses preliminarily the internal structure of metadata-based frameworks, helping in the understanding and development of such kind of framework.

Architectural patterns for metadata-based frameworks usage

The usage of metadata-based frameworks is becoming popular for some kinds of software, such as Web and enterprise applications. However, it is not clear for which kinds of problems this approach can be applied. This paper presents a study that investigated the metadata usage in existing frameworks and documented recurrent solutions as architectural patterns. As a result, software architects might use such approaches for similar problems, being aware of their benefits and drawbacks in each scenario.

A reference architecture for organizing the internal structure of metadata-based frameworks

Metadata-based frameworks enable behavior adaptation through the configuration of custom metadata in application classes. Most of the current frameworks used in the industry for building enterprise applications adopt this approach. However, there is a lack of proven techniques for building such kind of framework, allowing for a better organization of its internal structure. In this paper we propose a pattern language and a reference architecture for better organizing the internal structure of metadata-based frameworks, which were defined as a result of a pattern mining process applied to a set of existing open source frameworks. To evaluate the resulting structure generated by the reference architecture application, a case study examined three frameworks developed according to the proposed reference architecture, each one referring to a distinct application domain. The assessment was conducted by using a metrics suite, metrics thresholds derived from a large set of open source metadata-based frameworks, a process for automatic detection of design disharmonies and manual source code analysis. As a result of this study, framework developers can understand and use the proposed reference architecture to develop new frameworks and refactor existing ones. The assessment revealed that the organization provided by the reference architecture is suitable for metadata-based frameworks, helping in the division of responsibility and functionality among their classes.

A Qualitative and Quantitative Analysis on Metadata-Based Frameworks Usage

The usage of metadata-based frameworks is becoming popular for some kinds of software, such as web and enterprise applications. They use domain-specific metadata, usually defined as annotations or in XML documents, to adapt its behavior to each application class. Despite of their increasingly usage, there are not a study that evaluated the consequences of their usage to the application. The present work presents the result of an experiment that aimed to compare the development of similar applications created: (a) without frameworks; (b) with a traditional framework; (c) with a metadata-based framework. As a result, it uses metrics and a qualitative evaluation to assess the benefits and drawbacks in the use of this kind of framework.

Pattern Language for the Internal Structure of Metadata-Based Frameworks

Metadata-based frameworks are those that process their logic based on the metadata of classes whose instances they are working with. Many recent frameworks use this approach to get a higher reuse level and to be more suitably adapted to the application needs. However, there is not yet a complete best practices documentation or reference architecture for the development of metadata-based frameworks. This paper presents a pattern language that focuses on recurring solutions used in the internal structure of metadata-based frameworks addressing the main problems faced in this kind of development. Based on the pattern language, a reference architecture which identifies a base structure and the main hotspots for metadata-based frameworks is defined.

Idioms for code annotations in the Java language

Code annotations are a new feature introduced in Java 5.0 and ever since have begun to be widely adopted in the development of frameworks and applications. In order to provide better code structure and reduce the number of necessary configurations, the frameworks developed with code annotations used common practices in the annotation definitions. This paper presents a catalog that captures recurrent annotation solutions and documents them as idioms. As a consequence, the idioms can help the design of annotation schemas or be used in the optimization of existing ones.

Daileon: a tool for enabling domain annotations

Software developers currently understand that the real complexity in most applications lies in the problem domain the software is dealing with. The approach known as domain-driven design follows the premises that, for most software projects, the primary focus should be on the domain and domain logic, and that complex domain designs should be based on a model. For this type of project, the concept of domain annotations, which is a way to define annotations specifically for domain objects, can be applied. Currently, most part of metadata-based components still does not use this concept. This paper proposes two techniques for enabling the use of domain annotations in new frameworks and existing ones, and introduces the Daileon framework, which enables such development in Java-based applications.

Achieving quality on software design through test-driven development

Test-driven development (TDD) is a technique for developing and designing software where tests are created before production code in short cycles. There is some discussion in the software engineering community on whether TDD can really be used to achieve software quality. Some experiments were conducted in the last years comparing development by using TDD with one creating tests after the production code. However, these experiments always have some threats to validity that prevent researchers from reaching a final answer about its effects. This chapter, instead of trying to prove that TDD is more effective than creating tests after, investigates projects where TDD was successfully used, and presents recurrent and common practices applied to its context. A common mistake is to believe that just by creating tests before production code will make the application design “just happens.” As with any other technique, TDD is not a silver bullet, and while it certainly helps to achieve some desirable characteristics in software, such as decoupling and separation of concerns, other practices should complement its usage, especially for architecture and design coherence. In this chapter, we dive deep in TDD practice and how to perform it to achieve quality in software design. We also present techniques that should be used to setup a foundation to start TDD in project and to refine the design after it is applied.

Support for Refactoring an Application towards an Adaptive Object Model

Flexibility requirements can appear in the middle of a software development, perceived by several client requests to change the application. A flexible domain model, usually implemented with using the adaptive object model (AOM) architectural style, required custom-made components to handle the current implementation of the domain entities. The problem is that by evolving an AOM model, the components need to be evolved as well, which generates constant rework. This work studied the possible AOM evolution paths, in order to provide support in the components for model changing. An evolution of the Esfinge AOM RoleMapper framework were developed to provide this functionality, allowing AOM models in different stages to be mapped to a single structure. The study was evaluated using a set of tests that were applied in each possible structure for the model.