I’ll be at OSGi DevCon next week, having been given the opportunity to present the keynote session on Tuesday. The conference is co-hosted with JAX London. I thought I’d take a moment before jumping on the flight to offer a preview of what I’ll be speaking about.
The Cost of Complexity
The title of the session is OSGi in the Enterprise – Agility, Modularity, and Architecture’s Paradox. We all know that OSGi isn’t a new technology. It’s been around for over a decade. But the recent surge in interest in modularity on the Java platform is overdue. The complexity of software is increasing exponentially. Did you know:
- In 1990, there were 120 billion lines of code
- in 2000, there were 250 billion lines of code
- The number of lines of code doubles every 7 years
- 50% of development time is spent understanding code
- 90% of software cost is maintenance and evolution
Let’s put this in perspective using the visual at right (click to enlarge), where we can see that the amount of code doubles every seven years. Pretty staggering! But let’s put this in perspective for what it means over the course of the next seven years, as well. It means that between 2010 and 2017, we’ll produce more code than the total amount of code ever written combined! That’s staggering!
I decided to do a bit of research to see if I could find examples that supported these claims. I did:
- Since the Spring framework was released in 2002, the number of lines of code has grown more than 500% through the release of Spring framework 2.5 in 2008.
- FreeBSD contained roughly 8 million lines of code in 2002. In 2009, it was close to 16 million.
- In 2004, the Linux Kernel contained approximately 6 million lines of code. In 2009, it was around 12 million.
I’m sure many of us have experienced this phenomenon. Systems tend not to get smaller over time. And we also recognize that in almost every way, larger software systems are inherently more difficult to design, build, manage, and maintain than are smaller software systems.
Yet, such phenomenal growth is desirable. We can only hope that the systems we create are in such high demand that we have the opportunity to grow them over time. A software system that doesn’t change, dies. Evolution is a big deal! As Lehman’s law suggests:
As a system evolves, its complexity increases unless work is done to maintain or reduce it.
Add it all up, and there are some key takeaways here. We need something that will help us understand complex systems. We need something that help manage the complexity. We need something that will help ease maintenance. We need something that will help us deal with the natural evolution of software systems. We need something that will allow us deal with the natural architectural shifts that occur as a system grows to accommodate demand. For a long time, a central ingredient has been missing. But not for much longer, because the enterprise will get its OSGi!
For the rest of the story, see you in London.
Source of statistical information above: http://users.jyu.fi/~koskinen/smcosts.htm