Reply to “On scripting languages and Rockstar programmers” by s1038803.

I agree with the author that Rockstar programmers are rare. However, firstly I would like to point that there is a subtle difference between a programmer and developer, as the original author uses the term interchangeably. Although there are many definitions for both of the above circulating on the web I will choose a simple distinction between those terms.

  • Programmer is someone who writes code. Therefore a good programmer is someone who writes good code in a good way.
  •  Developer is someone who creates software. Therefore a good developer is someone who creates good software in a good way.

The above definition is deliberately vague to point out the main difference: the programmer is evaluated based on the code he writes, while the developer is evaluated based on the software he created. Neither good code does not imply good software nor good software does require good code (I do realise those things are highly correlated); the author put a lot of emphasis on the efficiency when writing code, a trait often associated with a good programmer, whereas it might not be relevant to creating and maintaining large scale projects.

On his blog, Scott Hanselman defined a Rockstar developer as someone who makes complex problems disappear, and then he made an argument that instead of Rockstar developers, there are Rockstar teams. The main reason behind it, that only a well interplaying team will make really complex problems just disappear, not a single programming diva.

On the other hand, the blog post I am replying to made a certain generalisation towards the “average” developer with which I disagree: he did not take into account the knowledge and experience when them.

It is true that scripting programming languages are more expressive and allow to write more succinct programs, however, when comparing someone’s performance while using a language, you should always take into account if that person knows the language already and if she or he has previous experience with it.

The main reason for that is even though it might be more difficult to do some task A in a systems language rather than a scripting language, an average developer might will do that task on schedule and within the budget provided that he has sufficient knowledge and experience with the task. Again, he might not be able to deliver the same task in an unfamiliar scripting language, even though the language itself might be simpler than the systems language. The knowledge of the tools you are using is extremely important, but bear in mind that there are certain habits developers get into, that make it really difficult to transition between different tools.

For instance, a developer used to C might struggle with Python’s dynamic typing — he will not check if he is passing proper arguments to methods because compiler was doing that for him. This case might seem silly, but it occasionally occurs to me or my colleagues when prototyping something in Python. Proper testing would probably check if everything is fine, but testing the arguments for types all the time is a significant drag and results in unmaintainable code.

Given all of the above and I assume that every developer is a programmer, but not every programmer is a developer, which I will not discuss in depth, because it is a topic for a whole another blog post. Therefore Rockstar developers are even harder to find than Rockstar programmers and I my opinion they are a myth.