Friday, 23 September 2011

The Benefits and Dangers of using Opensource Java Libraries and Frameworks

Everyone in the Java world seems to use various opensource libraries and frameworks... and why not, there are hundreds available covering virtually every type of programming problem you’re likely to come across in today’s programming landscape. This blog takes a quick look at the reasons for using opensource artifacts and examines what could go wrong...

The first reason for using them is reduced cost as it’s cheaper for your project to grab hold of an opensource library than it is for your to write the same thing yourself.

The second reason for using opensource artifacts is reduced cost: you get free support from a bunch of capable and enthusiastic developers, usually in the form of copious amounts of documentation and forums.

The third reason is reduced cost: you get free updates and enhancements from the opensource community and free bug fixes, although you don’t get to choose which enhancements are added to the project. Some projects, such as Tomcat, have a mechanism for voting on what enhancements are made, but at the end of the day it’s down to what really interests the developers.

There are also a couple of unspoken reasons for using popular opensource libraries and frameworks: firstly, they make your CV look good. If opensource X is popular and you put that on your CV then your chances of getting a pay rise or a better job will improve. Secondly, if you work on one of the opensource projects, then you’ll earn some kudos, which, again, makes your CV look good improves the chances of you increasing the size of your pay-packet.

There is an obvious downside to using opensource artifacts and that is all projects have an natural life-cycle. New versions of libraries are released, old libraries are deprecated, falling out of use because the technology’s too old, the developers have lost interest or moved on, or the rest of the community found something else that’s better and jumped on that bandwagon deserting yours.

So, the problems of finding yourself saddled with retired and deprecated opensource libraries are firstly extra cost: there’s no support, no forum and no bug fixes. You’re on your own. You can often manage to download the source code to retired projects and support it yourself, but that’s not guaranteed and that costs money.

The second problem of using deprecated code is extra cost: old code usually encompasses obsolete architecture and patterns, which contain known flaws and problems - after all, that’s why they’re obsolete. Using obsolete patterns and architecture encourages and in some cases forces developers to write bad code, not because your developers are bad, but that’s just the way it is... For example, there are some very obsolete JSP tags that blatantly mix database calls with business and presentation logic, which is a well know way of producing crumby, unmaintainable, spaghetti code.

The third problem is, believe it or not, extra cost: I’ve recently come across a project where the code is so old that there are JAR file clashes, with different JARs containing different versions of the same API being dragged into the classpath. Certain bits of the code use one version of the API whilst other bits use the other version. eclipse didn’t know what to make of it all.

There are also hidden costs: no one in there right mind wants to work on obsolete spaghetti code - it damages moral and saps the will to live, whilst damaging your ability to find that next, more highly paid, job. Plus, when people do leave, you’ve got the extra cost of finding and training their replacements. Never forget that the best people will be the first to leave, leaving you with the less experienced developers, again driving up your cost

So, what can you do when faced with obsolete opensource libraries and frameworks?

1) Do nothing, continue using the obsolete library and hope everything will be alright.
2) Scrap the whole project and start again from scratch - the Big Bang Theory.
3) Refactor vigorously to remove the obsolete opensource code. This could also be seen as a way of changing the architecture of an application, updating the programming practices of the team and improving the code and whole build process.

From the above I guess that you can figure out that in my opinion I prefer option 3. Option 1 is very risky, but then again, so is option 2: starting from scratch wastes time simply re-inventing the wheel, and whilst you do that, you don’t have a product, plus you may also end up with a big a mess as you started with. Option 3 is evolution and not revolution, quite the most sensible way to go.

Having said all this, I definitely won’t stop using opensource code...

4 comments:

Adam Perry said...

Scary thing is, the code you inherited is just 1 year old!

Roger Hughes said...

No it's not. The code I've just inherited was designed in about 1999 and has been copied from project to project for the past 12 years using cut 'n' paste technology.

Spyros Doulgeridis said...

Very nice and helpful article!

In the other hand, I have worked with web framework with proprietary license and full "support", and the support was not so supportive as expected. Moreover, in each release (~every 6 months) with have compatibility problems, because our code did not work with each release's modifications and so producing bugs. I do not disagree with you. I am just stating that proprietary frameworks are not so "perfect" :)

Regarding the article I must say that except from the very good analysis, the highlights in my opinion are
the "Big Bang Theory" (awsome!!! never heard it before :D ) and "Never forget that the best people will be the first to leave"!

Anonymous said...

You have extra costs when you compare to not using any library at all. But if didn't use opensource library you had to develop your own. And maintaining your own library costs as much as using retired and abandoned open source library.