I’ve noticed that alot of so called “developers” fall into the same camp that I was in. I’ve mentally made a distinction between a Programmer and a Developer. This is much more generic dictinction of different types of coders then say an Apprentice, Journeyman or Craftsman is.
A Programmer is someone who codes. They don’t necessarily take into consideration a whole lot of things outside of fact of getting the job done.
A Developer is someone who codes with consideration. They consider:
- coding quality and best practices
- program design with natural decomposition
- testability, automated testing, manual testing
- code performance (when its time to evaluate performance)
- responsibility to their customer and to their fellow teammate(s)
These definitions are influenced from object-oriented thinking and agile software development practices. You may completely disagree with them entirely. I’ve raised the bar for how I develop software. If it’s less for you then we just have different expectations of what makes a Developer. I’m ok with that. But, is your customer?
Ever since I started writing code I recognized that my potential was where I wanted to be. I could see the potential of what I could become and what I could accomplish. With this I had a genuine thirst for knowledge and I was eager to quench it. I’ve spent thousands of dollars and have read tens of thousands of pages from technical books. I’ve spent countless hours coding.
I spent too long of a time in the Programmer camp. I could have been much farther ahead early on given a few degrees change in direction.
So what was my problem? My problem had to do with the following goals when I first started:
- knowledge of multiple programming languages
- knowledge of different types of development: web apps, cgi, standalone,daemons, libraries
- coding speed
- all previous items as soon as possible
I wanted to know as much as possible in as little time as possible and I wanted to be able to produce results as fast as possible. A worthy goal, but the goals fell short of what is required of a software Developer.
When you learn as much as possible in the shortest amount of time with no regard to how you take that information and you end up learning only a small amount of what was there to be learned.
When you apply what you’ve learned as fast as possible with no regard to any of the aforementioned Developer “considerations” you end up making habits out of bad practices. And it will take alot of time and discipline to break them.
Developers take on a personal responsibility for the software they write. They don’t just value the end result. They value the entire process leading up to the end result and then they value the end result.
While Programmers continually apply bad practices, Developers provide consistently good practices. From what I’ve seen it goes like the following:
while Programmers avoid testing to produce faster short-term, Developers continue test to produce faster and more consistently long-term
while Programmers copy and paste over and over again to produce faster short-term, Developers refactor and create re-usable components to produce less buggy software, faster, long-term
while Programmers avoid the use of decomposition because everything can be inlined to produce faster short-term, Developers use decomposition to provide a solution which makes more natural sense (this leads to more manageable, maintainable, readable and scalable code for the long-term)
while Programmers often code by themselves to produce faster short-term, Developers value the input and ideas generated from other people to produce better and more correct solutions (this often leads to avoiding common mistakes from not correctly understanding the problem description and solution requirements)
while Programmers often code 12+ hours several days in a row to produce more in a shorter amount of time, Developers work a sustainable-pace to produce more correct code in a shorter amount of time (when you’re brain is tired and you are tired you make mistakes, if you keep on coding you just dig yourself a bigger hole. Staying fresh with a sustainable pace minimizes this.)
while Programmers commit to unrealistic customer expectations immediately, Developers communicate why the expectation is unrealistic and work with the customer on determining a realistic set of features in a realistic amount of time.
This isn’t to say that Programmers are evil coders. The term “Programmer” encompasses alot of people. These people might be:
- lacking discipline,
- or just bad programmers
Every coder starts out in the Programmer camp. Whether they evolve to the Developer camp is simply up to them. Who determines whether they’re out of the Programmer camp? They do.
Responsible Programmers quickly evolve into effective Developers because responsibility requires discipline and discipline does the right thing in any circumstance. The sooner you take responsibility for your craft as a software developer, the sooner you’ll enjoy the benefits of being a Developer.
blog comments powered by Disqus