Software Development

Open Source Java Libraries and Frameworks – Benefits and Dangers

Everyone in the Java world seems to use various open source 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 open source 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 open source library than it is for your to write the same thing yourself.

The second reason for using open source 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 open source 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 open source libraries and frameworks: firstly, they make your CV look good. If open source 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 open source 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 open source 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 open source 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 open source 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 open source 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 open source code…

Reference: The Benefits and Dangers of using Opensource Java Libraries and Frameworks from our JCG partner Roger Hughes at the “Captain’s Debug” blog.

Related Articles :

Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button