Summary

A framework for inverting the dependency in evolutionary and agile software development was presented. This framework utilizes the java annotation mechanism to specify the targeted service extension points in the base module for the new feature methods. A specific annotation processor is used to inject the corresponding commands into the byte codes before packaging and deployment for the run-time environment.

In this way, this framework mapped the original dependency in software development to the reversed dependency from the extension towards the base. Concerns and responsibilities of the developer roles in the software evolution are clearly separated. The CCP (Close Open Principle) in (Draeger & Mussawisade, 2011) is implemented by a simple, concise coding framework, which minimizes the run-time overhead and optimally support the heterogeneous needs for agility and stability in software developments.

By integrating the basic annotation framework within a Maven-based software configuration management environment. Different features extensions can be regarded as building blocks that can be comabined in building up applications with a flexible architecture. Obsoleted features can then be easily deleted from the application via deployment configurations. In this way, this approach for software development also supports the major features of a BPM framework, in that it enables the flexible configurations of business flows by composing different features/activities.

Basically this framework is comparable to the Aspect-oriented Programming (AOP) frameworks like AspectJ,  Spring or to the event-based framework for dependency inversion as proposed in (Draeger & Mussawisade, 2011).

An AOP framework typically requires a higher number of configuration files and gluing classes. E.g. in case of AspectJ we will need one class for the base logic, one for the extensions (aspects), one file for the configuration that maps the extensions to base classes/methods, and finally another class file which load the configuration in run-time to adapt the services. The existence of a large number of configurations after integrating numerous follower features will make the whole application less maintainable and understandable. 

The event-based framework intruduces similar complexity in specifing the event listners, registrations and processing. The dynamic, event-based run-time logic also makes it more difficult to make static analyses of the programs. Moreover, event management and processing will impose extra run-time overheads on the applications.

The key advantages of the new approach presented in this blog are its simplicity, easy configurability and maintability, and in its minimal overhead for the run-time environment.  Based on these features, this framework offers a better solution for extensive and major adaptation of service logics in an agile development process and in a bigger scale.



Start Page - Inversions of Dependencies for Agile Software Development

References:  

(Draeger &  Mussawisade, 2011) Joachim Draeger, Klaresch Mussawisade (2011), "Der Kreis schließt sich“, Javamagazin, 2/2011.