Agile Zone is brought to you in partnership with:

Rajaraman Raghuraman is a passionate software craftsman with 8+ years of experience in the IT industry. He is also the founder of AgileDevTest Blog (http://agiledevtest.blogspot.com) and author of an Ebook "Programmer's Motivation for Beginners" which is available at http://programmersmotivation.com. Rajaraman is a DZone MVB and is not an employee of DZone and has posted 4 posts at DZone. You can read more from them at their website. View Full User Profile

Attitudes of a Great Software Developer

01.15.2014
| 5790 views |
  • submit to reddit

This article was originally published at AgileDevTest blog (http://agiledevtest.blogspot.com).

Software development is an art, not just a science.  You can learn all the technicalities of software development, but you need to be absolutely passionate about coding and perceive it as an art to be extremely good at it.  If you are one such person, I will introduce you to the journey of becoming a "Great Developer".  The objective of a Great Developer, as i name him/her is to make his/her art as beautiful as possible and make it the best.

In my own thoughts, I will share some attitudes which a great developer should have apart from the general expectations of being technically and analytically sound, understanding requirements in detail, good design skills, etc.

Attitude #1 -  A bug is a question of my ability to write good code

Fixing bugs is part and parcel of a software developer's activities.  A bug is obviously the worst enemy of a Developer.  But how many developers think in the following lines while fixing the defects

·  What I could have done to avoid this bug in the first place?

·  How did I allow this bug to escape my eyes?

·  OK, something wrong has happened this time.  How do I avoid the same mistake next time? What steps do I need to take?

Truth is very few developers think on those lines.

A  person willing to be a great developer should consider a bug as a threat to his position, as a threat to his credibility, as a threat to his programming skills.  That is the attitude that will make him/her a great developer.

Attitude #2 - Mr. Tester, I challenge you to find bugs in my code

How many developers have this attitude?  Many developers think that the job of the testers is to find bugs.  Yes.  Obviously, but that doesn't mean as developers, we can take bugs for granted.

A great developer or a person willing to be a great developer should always invite / challenge the tester to find bugs in his/her code.  He should have so much confidence in his code that he can challenge in such a way.


Attitude #3 - No compromise on code quality

Code quality should be of prime importance to a developer.  That will include following the right coding standards, making the code more maintainable using proper design and code refactoring, etc, etc.  But how many of us compromise code quality for many reasons best known to us?

I can quote an instance in my project to explain this.  I was leading a team of developers and we were working on fixing something in the very last hours of a Friday night.  We had to give a build on Monday.  All of us were looking into the problem.  I got curious as I saw the problem and started getting my hands dirty in the code.  Time went by and only the last 5 mins were left for everyone's cab.  It was a make or break.  We had to come the next day, if that was not solved today.  I did something at that time, which absolutely infuriated all my team members.  Unable to see the clarity in the running code, I refactored a bunch of lines at that last minute.  Everyone were so pissed of, that they started scolding me :-) asking if it was so important at that moment.  I answered "Yes, it is that important".  Of course we worked the next day for other reasons, but the whole point was even though I had an option of fixing  the code in the running code, I chose to refactor the code not compromising on the code quality.

A great developer or a person willing to become a great developer should never compromise on the code quality, no matter what.

Attitude #4 - Confident but not arrogant

A great developer or a person willing to be a great developer should be absolutely confident of his abilities but should not be arrogant towards fellow developers and testers.  He should always remember that he is part of a team that is working towards a common goal of shipping a project on time with good quality.

Attitude #5 - Acknowledge the Tester

It can happen that despite all the hard work and efforts put in by the great developer, a great tester can still find defects in his code.  In those cases, acknowledge the great tester.

A great developer or a person willing to be a great developer should always acknowledge the tester for the bug that he found.  He/she should remember that the bug is the enemy, and not the tester :-)

With this I conclude this post, hope you find it informative.  Thanks for the read.  Cheers.

If you found this post useful, please share it with your circles.

About the Author

Rajaraman Raghuraman is a passionate software craftsman with 8+ years of experience in the IT industry. He is also the founder of AgileDevTest Blog (http://agiledevtest.blogspot.com) and author of an Ebook "Programmer's Motivation for Beginners" which is available at http://programmersmotivation.com.

Published at DZone with permission of Rajaraman Raghuraman, author and DZone MVB.

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

Tags:

Comments

Deepu Roy replied on Wed, 2014/01/15 - 6:42am

I would got to the extent of beating myself up over a bug as suggested in Attitude 1. My main concern when I cause a bug is (a) why did it happen? (b) how did it get through my unit tests (c) how can I write better tests to avoid a similar bug. 

Apart from that, the others are spot on. I would also add:

1. Being open to new approaches - someone may have a better approach to solving problem than my approach.

2. Teaching what I learnt - A lot of my skills were learnt by experiences of my mentors.

3. A problem-solving attitude - I've seen many programmers look at a bug and say "But that cannot happen" instead of saying "Ok, it happened. But, How?".

Rajaraman Raghuraman replied on Wed, 2014/01/15 - 10:44am in response to: Deepu Roy

Hi Deepu,

Very valid points.  I loved #1 & #2, yes you are absolutely right.  We all require mentors and we definitely should accept feedback and learn from our previous mistakes.  Very good points.  Thanks for commenting and keep visiting.  Thanks. 

- Rajaraman R

Agile Blog || Programmer's Motivation 

John J. Franey replied on Wed, 2014/01/15 - 2:30pm

Attitudes of a greater software developer:

Attitude #1: A bug is an indicator of your human fallibility.  Get used to it.  A greater developer makes mistakes.  A greater developer will release software with mistakes.  A greater developer makes fewer mistakes when it matters because he/she is supported by good practice.  


Attitude #2:  Please, tester, let me know the faults I have introduced to the system so that I may address them.  It is foolish to setup an adversarial relationship with the key member of the team who can help the greater developer produce the best product.


Attitude #3: A greater developer is prepared to compromise code quality for the sake of customer satisfaction.  A greater developer will advise the customer when risks in commitment have become apparent.  The delivery commitment has priority over the greater developer's sense of code quality.   The greater developer negotiates delivery commitment with the customer and is obligated to fulfill said commitment.  The greater developer has the obligation to advise the customer of risks to the commitment and subsequently proceed according to the customer's expressed request.  Greater developers do not introduce risk late in delivery cycle without advising the customer.


Attitude #4  A greater developer lacks confidence.   A greater developer understands that the last project, book or training does not provide enough knowledge to be successful on the next project.  A greater developer frequently refers to reference guides.


Attitude #5.  A greater developer is grateful and helpful to every contributor of the project.  A greater developer recognizes that working code has very little value if it is not tested, documented, administrated, released, supported, etc....  A greater developer shares success.

Harry Sheng replied on Wed, 2014/01/15 - 8:36pm in response to: John J. Franey

#3 +1


Rajaraman Raghuraman replied on Wed, 2014/01/15 - 10:43pm in response to: John J. Franey


Hi John

Interesing points.  I agree with some and I don't agree with some. The main essence of the article is to educate developers who lack the passion to become great or want to become great but keep on repeating the same mistakes.  (Maybe my assumptions didn't state that explicitly).

 

#1 - I would not agree with it fully.  I know its human tendancy to make errors, but we can't depend on systems to point out errors, we should be doing that pro-actively.  And developers don't get to decide whether they decide with the mistakes, it's often the project manager or Product manager who decides if we are good to go with the quality.  My point is as a Developer, we need to be at our toes to avoid previous mistakes and not make much new ones.

#2 - And here I am not meaning that developer should openly have a challenge with the tester, it's more mental & psychological.  Since a developer takes lot of pride in his code, he is so confident of his code that he challenges the tester to find defects (Not explicitly however :) ).  The point is they should be very competitive.  Competition and ego are two different things.  First one is healthy and second one is not.  And I am saying compete and challenge.  And that has got nothing to do with relationships, developer and tester can have a good relationship while maintaining competitive spirit within the team.

#3 - Agreed to this point, I would also like to add "If in case code quality is compromised in the short run, a great developer has the responsibility to highlight the difficulties that the project will face in the longer run to all stake holders and take appropriate actions to correct it in the long run"

#4 - Agreed partially, but I still go with a developer being confident enough about his abilities.  That comes from his skills and the other attitudes that he possesses and that makes him confident, but the point that I tried to make it was not to go overboard with it as overconfidence can lead to arrogance in some form and that to me is very bad.

#5 - Fully Agreed !!

 

- Rajaraman R

Agile Blog || Programmer's Motivation 

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.