The Need to write Clean and Maintainable Code

-
Building software nowadays getting more and more difficult. Developers has to keep up with the always changing frameworks and technologies. We always feel that, "Can I keep up with these changes and stay competitive?" There is plethora of tools and frameworks to choose from to solve a problem, and still there are very few or none to solve the biggest issue, the issue of writing a good code which is flexible and easy to maintain. Every developer, while executing a project has to go through various stages. Before writing any code, He has to gather and understand all the requirements, he has to choose required tools and framework, he need to make sure that he meets the deadline and after doing all this, there is Maintenance. If deadlines are strict developers tends write code in a hurry which just works. Such kind of approach results in a code which after some time becomes hard to understand, hard to maintain and can take more time and energy to add simple feature to the software. In such situations even adding or extending the code can break some other part of the software. Another major problem with this approach is, new developers who are on boarded, find it very difficult to work with such codebase and if the new developers are not skilled it will be a giant mess. After all this Management decides to clear the mess (which is very difficult now) by hiring skilled developers, but the skilled developers can’t do anything but to duct tape. It’s a common story for many projects.

                          Reference  : Clean Code: A Handbook of Agile Software Craftsmanship

Writing perfect code is a myth. The good code is the code which evolves over the time with the understanding of the domain. Adding features to such kind of code is easy. If the code is self-explanatory and can be read as a textbook paragraph, then there is no overhead of documenting the code. Anyone can read this and understand it without any extra efforts. There are many principles like SOLID, YAGNI (You aren't gonna need it), DRY (Don't repeat yourself) etc., which help developers to write a good code which is highly scalable and easy to maintain. In my opinion this is a pragmatic approach a developer should follow. Before starting the project the team should set basic rules like what and how the naming convention is going to be, how many lines of code a class or a method should have etc.
Whenever required a developer should refactor the code. The code evolves over time, and it’s quite common that a code written with one context in a mind has to be refactored while in the other. You might follow all the principles and patterns and yet sometimes you may still feel that you have done it all wrong. In such situation refactoring the code is the best approach.
Writing a good and maintainable code is an Art, a craftsmanship. There are many resources covering this topic, below are some which I really find helpful to develop these skills.
1)      Clean Code: A Handbook of Agile Software Craftsmanship by Robert c. Martin
2)      Code Complete: A Practical Handbook of Software Construction by Steve McConnell
3)      The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt
4)      Refactoring: Improving the Design of Existing Code by Martin Fowler

Comments

Post a Comment

Popular posts from this blog

Threading in .Net – Part I – The Basics.

-
Image
The Problems with Single Threaded Systems In early days of computers the entire operating system was executed on a single thread. The problem with these kind of systems back then was the long running tasks would prevent the execution of other tasks causing the other applications and OS to stop responding, And if the long running task has some bug in it, or if it goes to an infinite loop then the end user has no choice but to reset the system. This was a common problem for the 16-bit systems, as they were able to access only 1MB of memory. Microsoft knew that 16-bit Windows would not be a good enough operating system to keep Microsoft relevant in the industry, so they created a new OS to address the needs of Corporations and individual. Microsoft designed the new OS (Windows NT), they decided to run each instance of an application in its own Process. A Process is nothing but a collection of resources that is used by a single instance of an application. Each Process in windows has g...
Read more

Writing High Quality Functions

-
Image
Ever wonder how to write clean functions/methods? While searching for the answer you might have come across some metrics, stating your function should not be more than 25 lines of codes or it should not have more than 5 arguments passed to it etc. When it comes to quality, unfortunately such metric are bad indicator to measure the quality of the function. It will just trigger a flag that there is an issue, but it will not tell what the issue is. When writing a high quality function, the first and primary rule is functions should be small, it should only do one thing. Sounds like Single Responsibility Principle? (SRP) yes it is, you can apply SRP not only to class, but to functions as well and this is the only measure you can use to check if the function you have written is of high quality.  FUNCTIONS SHOULD DO ONE THING. THEY SHOULD DO IT WELL. THEY SHOULD DO IT ONLY.                               ...
Read more
-
Image
Domain Driven Design A good code base creates value for the organization and to the client. The better the code reflects the problem domain the more Money it is going to create for the organization. In his book (Domain-Driven Design: Tackling Complexity in the Heart of Software), Eric Evans first introduced the Philosophy of the Domain Driven design (DDD). While the full explanation would take a couple of 500-page books, the essence of DDD is profoundly simple: capture the domain model in domain terms, embed the model in the code, and protect it from corruption. Although let me warn you DDD is not A Silver bullet for every problem It is not the new Shiny/Trendy design pattern it is not a new template in the latest and greatest IDE’s And certainly not some coding standard/guidelines for the rookie software developers. Why one should explore and apply DDD practices? It always feels good when you look at the code which is written by you sometime back, and you are still able...
Read more