Andrew Boake

Fine-grain transformations to refactor UML models

The current trend is to apply refactoring at levels of abstraction above the code level. We present a new approach to formalize model refactorings. The approach is based on the semantics of a predefined set of fine-grain transformations (FGTs) that can be used to construct any refactoring, and relies on logic-based representations of the UML model. The proposed approach has many features: it gives the ability to detect and resolve conflicts; to remove redundancies; to find sequential dependencies between refactorings; and to increase parallelizing opportunities. In addition, it enables the end user to build their new refactorings. Based on the proposed formalism we also introduce a new technique to find automatically the order of a batch of refactorings.

Refactoring Tools and Complementary Techniques

Poorly designed software systems are difficult to understand and maintain. Modifying code in one place could lead to unwanted repercussions elsewhere due to high coupling. Adding new features can cause further quality degradation to the code if proper design and architectural concerns were not implemented. Development in a large enterprise system with such attributes will, over time, lead to a myriad of concerns unless the system is periodically overhauled or refactored in some way. Refactoring can aid the developer to improve the design of the code and to make it cleaner, without changing its behaviour. This study provides answers for some of the questions on refactoring. A refactoring tool survey is given. The IDEs surveyed include some of the most popular commercial and open source offerings from IntelliJ’s IDEA, IBM’s Eclipse and Sun’s Netbeans. We also explain a way to automatically find targets for refactorings via automatic detection of code smells from static code analysis. Concerns on viewing compiler refactorings as a fully automated refactorings are raised. We will perform a critical evaluation of refactoring by surveying these tools.

Corporate-, Agile- and Open Source Software Development: A Witch's Brew or An Elixir of Life?

The observation that the Open Source Software development style is becoming part of corporate software development, raises questions about its compatibility with traditional development processes. Particular compatibility questions arise where the existing corporate development style is in the agile tradition. These questions are identified and discussed. Measures that can be taken to avoid clashes are suggested. An example illustrates how Corporate-, Agile- and Open Source Software could intersect, and SPEM modelling is employed to show how corporate processes would need to adapt to accommodate the new scenario.

Extreme Programming: A Kuhnian Revolution?

This paper critically assesses the extent to which the Agile Software community’s use of Thomas Kuhn’s theory of revolutionary scientific change is justified. It will be argued that Kuhn’s concepts of “scientific revolution” and “paradigm shift” cannot adequately explain the change from one type of software methodology to another.

Literate Programming to Enhance Agile Methods

In this position paper, after explaining the essentials of literate programming, we argue that a literate programming style is consistent with the values espoused by agile software development; and that the application of literate programming in the context of an agile software development methodology is likely to enhance both the quality and lifespan of the final product.