MaintainJ Blog

February 8, 2012

Vielen Dank, Thank you, Mille grazie, Merci!

Filed under: Uncategorized — maintainj @ 10:00 am

I recently got an email from someone I didn’t know which ended with the above line. I hit ‘Reply’ and started the email with ‘Hi Vielen’ thinking that ‘Vielen Dank’ is the name of the sender. It has a neat first and last names after all and sounds like a women’s name.

But wait, I know what ‘Merci!’ means, why would someone repeat ‘Thank you’ twice? I did a quick Google search to find that ‘Vielen Dank’ means ‘Thanks’ in German.

–Choudary Kothapalli.

February 2, 2012

Don’t try to understand the whole application when starting on a new project

Filed under: Uncategorized — maintainj @ 6:09 pm

I posted an answer to someone’s question as below on Stackoverflow.

The question:
I have an application written in Java. In is stored in several files. It uses different classes with different methods. The code is big and complicated. I think it would be easier to understand the code if I have a graphical model of the code (some kind of directed graph). Are there some standard methods for visualization of code. 

My answer:

This is an old question, but as this is coming up in Google searches, I am adding my response here so that it could be useful to the future visitors. Let me also disclose that I am the author of MaintainJ.

Don’t try to understand the whole application

Let me ask you this – why do you want to understand the code? Most probably you are fixing a bug or enhancing a feature of the application. The first thing you should not try to do is to understand the whole application. Trying to understand the entire architecture while starting afresh on a project just overwhelms you.

Believe me when I say this – developers with 10+ years of solid coding experience may not understand how certain parts of the application work even after working on the same project for more than an year (assuming they are not the original developers). They may not understand how the authentication works or how the transaction management works in the application. I am talking about typical enterprise applications with 1000 to 2000 classes and using different frameworks.

Two important skills required to maintain large applications

Then how do they survive and are paid big bucks? Experienced developers usually understand what they are doing; meaning, if they are to fix a bug, they will find the location of the bug, then fix it and make sure that it does not break the rest of the app. If they need to enhance a feature or add a new feature, most of the time, they just have to imitate an existing feature that does a similar thing.

There are two important skills that help them to do this.

  1. They are able to analyze the impact of the change(s) they do while fixing a bug. First they locate the problem, change the code and test it to make sure that it works. Then, because they know the Java language well and the frameworks ‘well enough’, they can tell if it will break any other parts of the app. If not, they are done.
  2. I said that they simply need to imitate to enhance the application. To imitate effectively, one needs to know Java well and understand the frameworks ‘well enough’. For example, when they are adding a new Struts Action class and adding to the configuration xml, they will first find a similar feature, try to follow the flow of that feature and understand how it works. They may have to tweak a bit of the configuration (like the ‘form’ data being in ‘request’ than in ‘session’ scope). But if they know the frameworks ‘well enough’, they can easily do this.

The bottom line is, you don’t need to understand what all the 2000 classes are doing to fix a bug or enhance the app. Just understand what’s needed.

Focus on delivering immediate value

So am I discouraging you from understanding the architecture? No, not at all. All I am asking you is to deliver. Once you start on a project and once you have set up the development environment on your PC, you should not take more than a week to deliver something, however small it may be. If you are an experienced programmer and don’t deliver anything after 2 weeks, how can a manager know if you really working or reading sports news?

So, to make life easier for everyone, deliver something. Don’t go with the attitude that you need to understand the whole application to deliver something valuable. It’s completely false. Adding a small and localized Javascript validation may be very valuable to the business and when you deliver it, the manager feels relieved that he has got some value for his money. Moreover, it gives you the time to read the sports news.

As time passes by and after you deliver 5 small fixes, you would start to slowly understand the architecture. Do not underestimate the time needed to understand each aspect of the app. Give 3-4 days to understand the authentication. May be 2-3 days to understand the transaction management. It really depends on the application and your prior experience on similar applications, but I am just giving the ballpark estimates. Steal the time in between fixing the defects. Do not ask for that time.

When you understand something, write notes or draw the class/sequence/data model diagrams.

Diagrams

I started with the disclosure that I am the author of MaintainJ, the tool that generates runtime sequence diagrams. Let me tell you how it can help you.

The big part of maintenance is to locate the source of a problem or to understand how a feature works.

MaintainJ generated sequence diagrams show the call flow and data flow for a single use case. So, in a simple sequence diagram, you can see which methods are called for a use case. So, if you are fixing a bug, the bug is most probably in one of those methods. Just fix it, ensure that it does not break anything else and get out.

If you need to enhance a feature, understand the call flow of that feature using the sequence diagram and then enhance it. The enhancement may be like adding an extra field or adding a new validation, etc. Usually, adding new code is less risky.

If you need to add a new feature, find some other feature similar to what you need to develop, understand the call flow of that feature using MaintainJ and then imitate it.

Sounds simple? It is actually simple, but there will be cases where you will be doing larger enhancements like building an entirely new feature or something that affects the fundamental design of the application. By the time you are attempting something like that, you should be familiar with the application and understand the architecture of the app reasonably well.

Two caveats to my argument above

  1. I mentioned that adding code is less risky than changing existing code. Because you want to avoid changing, you may be tempted to simply copy an existing method and add to it rather than changing the existing code. Resist this temptation. All applications have certain structure or ‘uniformity’. Do not ruin it by bad practices like code duplication. You should know when you are deviating from the ‘uniformity’. Ask a senior developer on the project to review the changes. If you must do something that does not follow the conventions, at least make sure that it’s local to a small class (a private method in a 200 line class would not ruin the application’s esthetics).
  2. If you follow the approach outlined above, though you can survive for years in the industry, you run the risk of not understanding the application architectures, which is not good in the long run. This can be avoided by working on bigger changes or by just less Facebook time. Spend time to understand the architecture when you are a little free and document it for other developers.

Conclusion

Focus on immediate value and use the tools that deliver that, but don’t be lazy. Tools and diagrams help, but you can do without them too. You can follow my advice by just talking some time of a senior developer on the project.

–Choudary Kothapalli

Powered by WordPress