Because of it’s emerging significance and my increased interest, I’ll be posting a number of entries related to OSGi. I’ll share some ideas on how OSGi stands to transform enterprise Java software development and application delivery, present some samples that illustrate these ideas, and offer a few opinions regarding the JCP and the various JSR’s that intend to accomplish similar ideals. I’m hopeful that my unbiased opinion will help developers more fully understand the value that OSGi brings to the enterprise. To help you quickly find all OSGi related entries on this site, I’ve created a separate blog category under which I’ll file these posts. I’ve also added a separate page that links to a number of other useful OSGi specific articles, websites, and blogs. If you are aware of an on-line resource related to OSGi, or know of one not on the current list, let me know and I’ll add it.
For quite some time, I’ve felt that the lack of a component technology has left a gaping hole on the Java platform. In fact, this is what led me to begin development on JarAnalyzer back in 2001 in the hope that I could help developers understand the component modularity of their existing applications. It’s also what led me to found Extensible Java in the hope that I could offer some design guidelines surrounding component modularity when developing large enterprise software systems in Java. The idea of a component technology that brings greater modularity to the Java platform is very exciting. This is my first OSGi-related post, so let’s start at the beginning. Why?
The distiction between software architecture and design is subtle, and countless trees have been sacrificed attempting to differentiate between the two. Booch sums it well, pointing out that it’s the cost of change separating the two.
All architecture is design but not all design is architecture. Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change.
Cost of change can be measured in many different ways, and is contextual. Financial cost, technological risk, and derived business value are examples of what might factor into that cost. However you slice it and dice it, the business value of design is to craft a software design that minimizes the cost of change by maximizing adaptability to change.
The ability of software to adapt, however, is not constant. As unexpected shifts in technology and business occur, the original design may not accommodate current needs. Should this occur in an architecturally significant area of the system, the cost of applying the correct change may exceed the immediate business value. As this happens throughout the life of a software system, software design degrades to the point where most change is no longer cost effective, and the temptation to hack a compromised solution is great. As this begins, and continues to occur, the software is beginning to rot.
Fowler discusses Design Stamina Health in making the compelling case that software design is a worthwhile activity. I doubt many of us disagree with his conclusion, assuming that the resulting design realizes the intended goal – that it can evolve. While good software designs are able to evolve based on the known factors today, the unforeseen factors of tomorrow reap havoc on design. I doubt we can ever entirely defeat these forces, but many techniques have been discovered that allow us to craft more adaptable software designs. Object-oriented development, design patterns, software code quality metrics, design quality principles, emergent design techniques such as Test-Driven Development, and Service Oriented Architecture all represent a positive step. Yet for large enterprise software systems, there is still a key ingredient missing in delaying design rot. On the horizon looms a disruptive technology, codename OSGi, that stands to redefine how we think about designing enterprise software on the Java platform.