Agile Zone is brought to you in partnership with:

Mr. Mahal has worked his way through all aspects of software development. He started as a software engineer and learned how to design and architect software systems in different industries. He has been a director of engineering, product management, and professional services; mid-career he worked for a company dedicated to training engineers in collecting requirements and understanding OO and conducted research into why software projects fail; and before starting Accelerated Development he rescued a technology startup in Vancouver as their COO. Accelerated Development is dedicated to the production of high quality software through implementing light weight engineering practices for all size organizations up to Fortune 500. Dalip is a DZone MVB and is not an employee of DZone and has posted 36 posts at DZone. You can read more from them at their website. View Full User Profile

Productive Developers are Smart and Lazy

04.21.2014
| 6326 views |
  • submit to reddit
When I use the terms Smart, Lazy, and Developer; I mean the following:
  • Developer as in energetic and focused on building real-world code solutions
    • Not a dreamer who never gets around to writing anything practical
  • Smart as in able to think things through (i.e. not smart-ass)
  • Lazy as in lazy-loading, that is taking time to write code (i.e. not couch potato)
Good development is lazy development a.k.a. patient development; it happens when the developer spends the time necessary to think through all the pathways of the solution that he is developing BEFORE writing the code. That is lazy-writing of code, i.e. not writing code before the problem is understood. The more due diligence a developer does to make sure that he is writing the correct code will reduce the amount of code that needs to be written.
This due diligence takes the form of:
  • Really understanding the requirements and getting product management (business analysts) to be clear on what are the ACTUAL requirements
    • They often are not given time to gather requirements
    • They often don't have access to the right subject matter experts
    • They sometimes have very poor abilities to synthesize consistent and complete requirements (see When BA means B∪ll$#!t Artist)
  • Really making sure that you understand how you are interfacing to other developers on your team and other teams, this involves:
    • collaboration in front of a white board
    • producing diagrams (UML and Visio)
It takes time to do this due diligence to make sure that you have consistent requirements and to make sure that you will have consistent interfaces with your peers. However, developers are eager to start banging out code and spend hours at their desks banging out code.

In reality, less than 5% of that time is spent productively (see The Programmer Productivity Paradox). If you see developers spending 100% of their time staring at their screens with no human interaction then you are looking at some of the worst developers.
It is a bad sign if developers always coding
Productive developers are constantly checking their understanding of the requirements and making sure that they are staying in sync with their team's code. Productive developers are in regular contact with the product managers/business analysts and can often be seen white boarding with their peers and architects. There are definitely developers who use their years of experience to become more productive, in fact among the best developers:
  • the ratio of initial coding time was about 20 to 1
  • the ratio of debugging times over 25 to 1
  • program execution speed about 10 to 1
  • program size 5 to 1
However, in the aggregate, developers do not become more productive over time (see No Experience Necessary!), i.e. over thousands of developers there is no correlation between years of experience and productivity. In fact, we have measured productivity regularly 8 times over the last 50 years and years of experience do not correlate (in the aggregate) with productivity.
Why is lazy writing of code so important?
Code is often written before the requirements are understood or gathered. In addition, quickly written code often fails to fit with everyone else's code; often, it is only during integration that this problem is discovered. Good developers are patient and realize that there is a cost to writing code quickly.

Developers become psychologically attached to their code 

Bad developers are reluctant to change poorly written code. Rather than rewrite suboptimal code, bad developers will simply add more code to make up for deficiencies. Even worse, they tend to blame everyone else for having bad code. What you end up with is band-aid after band-aid that leads to a severely buggy and unstable system.
Don't get me wrong, good developers can find themselves in a situation where they have written sub-optimal code. The difference is that a good developer will recognize a problematic section of code and:
  • Refactor the code if the code is largely doing the right thing
  • Rewrite the the code otherwise
When developers produce and maintain sub-optimal code, it becomes harder and harder to change this code as time goes on. That is because their peers will need to write code that interfaces with the suboptimal code and build clumsy interfaces or work-arounds to make the code work. As the code base grows, too many later code units rely on the functionality of this initial code. Of course, the later code can do little to increase the stability of the code and bugs multiply when simple changes are made; in short, development becomes slower and slower.

When in doubt, be lazy and write code late!

 

Published at DZone with permission of Dalip Mahal, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)