Friday, December 30, 2016

10 Programming Tips to Create Maintainable Java Applications

Hello all, today is 31st December, the last day of 2016 and this is probably the last post on Javarevisited for this year and I want to make it special. That's why I am going to share you some tips on creating maintainable Java applications which will help you not just in the new year, but also in all the coming years in your software development career.  One aspect of development, which is often overlooked by developers is to create applications which are both easy to maintain and support. Since a software spends 90% of its lifetime in maintenance mode, it's very important that your application is easy to configure, support, and maintain. Also, Java application is no different than any other software, you must pay attention to these key properties of writing production quality code, hence this tips also applies to any programming language which is used to create real-world software which is used by real users.

If you have work in large organization e.g. Investment banks e.g. Barclays, Citibank, or big Insurance companies you will find how important is support and maintenance of production applications are. There are several more software engineers working in support role then programmers developing software. You have L1, L2, and L3 support and then dedicated support team for every application. This means support is really important.

But, when programmers develop an application, they focus on features and speed of development e.g. how quickly a feature is ready for testing etc, and to achieve these many programmers including myself in past often ignore things which matter a lot in production.




How to Make Java Application more Maintainable

Here are some practical tips to make your Java application more maintainable. Always remember, maintenance cost is much higher than development cost and it's easy to give a solution but it's equally difficult to give a maintainable solution i.e. something which can withstand the test of time.

Before going to explains these 10 tips which can make your Java application more maintainable and easy to support, let me tell you that I have personally made a lot of these mistakes myself. It requires a great deal of discipline, hard work, and to be vigilant about writing quality code. Sometimes you have to push back even to your team lead or managers bringing the points like support, which is often overlooked.



Don't swallow exceptions
Please avoid swallowing the exceptions. The stack trace is the most valuable troubleshooting information. In the production system where the priority is to bring the system up and then find the root cause, these exceptions are gold, without them, you will never be able to find what happened with your application at that moment. On the other hand, please don’t print the stack trace multiple times. Printing a stack trace is a resource intensive process and should be controlled i.e. you print more information while running on DEBUG or INFO mode and only print essential information while running in PRODUCTION mode. This is an example of swallowing exception in Java:
try{
   // do something

}catch(FileNotFoundException fe){
   // do nothing
}

This is also known as empty try-catch block and many static code analysis tools like Fortify will catch these in the early stage of development.  This also highlights the important of static code analysis in Java development. Make sure, you integrate static code analysis tool as part of your build process.

If you are still not convinced on static analysis, then please read my post why static code analysis is important, that will give you more reasons to use it in your project.


Avoid excessive logging
This tip is closely related to the first one and at first it may look contradictory but in reality, it's not, in fact, they both compliment each other. When you run the Java application in your development environment (PC), nobody cares what’s the logging level you have. Go ‘DEBUG’ or ‘ALL’ if you please. But when it goes to production (or other higher environments e.g. QA or UAT ), limit your logging to ‘INFO’ or ‘ERROR’. Excessive logging has 3 major impacts:

1. It puts unnecessary load on the Application. I’ve seen throughput of application is reduced to half due to excessive logging.

2. It can fill up the file system very quickly and that can create issues for your application and other applications hosted on the same server. This is a serious problem especially if you are co-hosted with some other application. Do you know what will happen when root directory of certain flavors of Unix system fills up? - that’s right. No one can login into the host.

3. Troubleshooting will be painful, like looking for a needle in a haystack (if the poor support guy can ever get the log file to open).

In short, you have to keep the balance between excessive logging and not enough logging and to be honest that is also an art, which requires a good knowledge of both application and domain. This is also where experience comes into the picture, involve support guys from the UAT itself, they will give you valuable tips on logging and support of the application. Remember, life is all about keeping right balance :-). See here for more logging tips for Java developers.

Programming Tips to Create better Java Applications



Don't Forget to Close Database Connections
This is one of the most common reasons for production issues in the last decade, but thankfully with modern frameworks and library, this issue is actually slowly disappearing (as the framework takes care of opening/closing connections). However, make sure you always ‘close’ the database connection so that it is released back to the pool. This is also one of the JDBC best practices, I have shared with you in my earlier post 10 Essential JDBC best practices for Java programmers. If you haven't read it yet, make sure you read it on 2017.

A common mistake is not closing the connection in the ‘finally’ block of a ‘try catch’. If there is a connection pool leak, your connection pool with be exhausted soon and your user will experience immediate slowness.

The same rules go to closing sockets and streams if you don't close them you will run out with resources pretty soon. Sometimes, Java developer think that they have closed the connection but in reality, they were not closed, hence you must know the right way to close streams in Java.

This is part of general resource management best practices. Not to discourage you but I have personally found C++ developers excel Java developers when it comes to resource management. They are more vigilant about closing the connection and releasing resources, something Java developers can learn from C++ programmers.



Don't underestimate production load
If you are an experienced Java developer you would have noticed that most of the issues are exposed in the production environment rather than in UAT or QA environment, especially concurrency related issues? Do you know why? because of production load.

You might have heard developer talking to support personnel that  ‘It works fine in my development environment. But when it went to production, it crashed’.

Yes, it is the job of the load testing team to test your application with the production like load. But that does not mean that as a developer you write code that does not scale well. For example, it works fine for 1 user, but what happens when there are 500 users online simultaneously.

The issue is brutally exposed while writing concurrent code because the probability of race condition is much higher in production than any other environment. So, always keep production load in mind and code.

You should also read my post about essential multi-threading and concurrency best practices for Java programmers if haven't read already. That will help you to envision some of the things which you might not think otherwise.

10 Programming Tips to  Easy to support Java Applications



Avoid loading large result sets from Database
This is one of the common mistakes made by beginners and intermediate Java programmers who don't know about paging or pagination. You simply cannot load every record e.g. order or trade from database in one call. In some cases, obviously, you will run out of memory and it is also a waste of network bandwidth, CPU and memory as the user might not need all of those data.

Secondly, you just cannot keep the data in your application forever because it may become stale hence you need to load it again.

So, instead of loading all records in one go, implement some sort of ‘pagination’ and/or ‘lazy loading’ so that you don’t have to load everything in the beginning.

This is where ORM and caching framework like Hibernate helps a lot. They simply free up Java developers from worrying about lazy loading and pagination. If you want to learn more how lazy loading works in Hibernate, I suggest reading Java Persistence with Hibernate or High-Performance Java Persistence by Vlad Mihalcea both are great books which every Java developer using Hibernate should read.

10 Programming Tips to create Maintainable Java Application



Avoid hard coding Configuration Parameters
You might have heard this tip several times but you would be surprised if you look at the code written by many professional software engineers and programmers. There is hardly a code where something is not hard-coded but hard-coding configuration values like URLs, directory locations, username/passwords, cache sizes, log levels etc in the code results in hard to maintain Java applications.

Instead of hard-coding configuration parameters, you must externalize them in a property file. It seems simple enough but I have seen it over and over again that somehow some hard coded value sneaks in and breaks when it goes to production. In one word, managing configuration information within the code is a nightmare. Never do that.

There is a flip side as well, where many programmers just create too many property files with the hope to generalize everything. It does make sense to keep related properties in one place e.g.  if a couple of configuration parameters is shared by multiple application then externalize them in one property file e.g. database and middleware URLs, username, password etc and let other application import that file, but if you do it over a limit then it becomes a maintenance nightmare. 

You should also never mix environment-related configuration parameters e.g. URL, directories, username/password with application related parameters e.g. config parameters to enable disable some functionalities. It's better to keep separate properties file for application properties and environment properties. This way, you would have one application properties across the environment which are essential for testing and production release. 



Don't write Platform specific Code
Many Java programmers just don't give a shit to writing platform specific code, thinking that Java is platform independent. Even though Java is platform independent, if you are not careful you will end up making your Java application platform dependent. Java programmers should not code anything that is related to the local operating system. For example, executing a Linux command (example: uname -a) from java and handling the output.

This will not work whenever your company decides to move to Windows from Unix and it will be painful to refactor hundreds of lines of code containing such code. This is again the case where static code analysis can help you a lot. Make sure you integrate tools like Sonar or Fortify in your build process to regularly scan code for such code smells.

Programming tips for Java developers



Consider Clustering
This is one area where even many experienced Java programmer also fails. Since every application doesn't run in the cluster it's possible to not thinking about clustering at the start but if you ever decide to run your application in a cluster in the later stage of development, it would be really hard to refactor your application.

For example, if you have a scheduled job within the code, what will happen to it if you run multiple instances of the same application? Wouldn’t it run multiple times? What are the side effects of this?

It's best to think to cluster at the start of development and avoid scheduling jobs from Java code directly, think about using more useful tools like Autosys for Job scheduling and monitoring.


Avoid packing multiple versions of same JAR files
Packaging utility jar files in several places, especially various versions of the same utility jar in various locations is the cause of many production issues.

You must have a clean build and versioning processing, especially for internal applications.  Consider using Maven for dependency management, it makes life a lot easier than keeping versioned JAR files in the lib folder.

The infamous ‘ClassCast Exception’ or ‘NoClassDefFoundException’ is most of the times due to the version mismatch of third party jar files. Make sure you only package one copy of the jar file and your build is consistent across environments e.g. Dev, QA, UAT etc.

It's also a good practice to keep configuration separate from binaries so that you can release same binaries across the environment e.g. promoting the same binary from UAT to Production after testing successfully.


That's all about some practical tips on how you can make your Java application easy to support and maintain. These small things can make big difference when it comes to developing and maintaining a real-world Java application. If you are aspiring to become a solution architect or Java architect, paying attention to these details will help you put your case forward more strongly. A good Java architect will ensure that application is both easy to maintain and support.

You can also do good if you include various stakeholders early in development stage e.g. support team, testing team, middleware guys, Unix and infra guys, networking peoples and business guys. Though, don't overwhelm with a lot of details coming from every direction, just keep calm and drive.

Other Java best practices article to improve code quality of your Java applications:
  • 10 Java Exception Handling Best Practices (read)
  • 10 Java Multithreading and Concurrency Best Practices (click here)
  • 10 Programming best practices to name your variables (learn)
  • 10 Tips to Avoid NullPointerException in Java? (read)
  • 5 Method and Constructor Overloading Best Practices in Java? (learn)
  • 10 JDBC Best Practices for Java Programmers (learn)
  • 10 Tips to follow while writing Code Comments (follow)
  • 10 Logging Best Practices Every Java Developer should follow (read)

These were some collections of essential best practices for Java programmers, but you will find a lot more if you explore the Javarevisited blog e.g. why use SLF4j for logging over Log4J in Java etc. I have shared a lot of small tips and best practices which will help you to write better code in Java. Once you learn about them they will go into the back of your mind and alert your whenever you are writing code which violates those rules.

Though these best practices will help you to write better code in Java, they are not substitutes of good programming habit and essential programming best practices given in the Clean Code by Uncle Bob Martin. If you want to do one thing in the new year to improve your programming, I suggest you must read the Clean Code next year.


Happy New Year 2017 !!!

3 comments :

John Watson said...

Hi!It was only have 9 tips.:)

Javin Paul said...

Thanks for reading article John, yes, it is indeed 9 tips in headlines but a lot more if you read details :-). Don't worry I'll add more if you guys like this kind of posts.

Mallikarjuna Budur said...

Nice

Post a Comment