I recently stumbled accross this article from a few years ago. It argues that significant differences in the culture surrounding VB and C#, not the actual differences in the language, contribute to C# coders being generally more talented than VB coders. Obviously, that caused a lot of flame wars and the question of whether C#ers or VBers are the dumber will never be answered. That being said, the writers claim that the culture surrounding a particular platform contributes to the quality of the team could still be plausible. For example, even though Java is more efficient to develop apps with at the moment, a team of Google Go developers would seem likely to be of a higher caliber on average than a team of Java developers, since to learn Go, a developer probably has to be a super-early adopter and a frontier-hacking whiz. So, in a nutshell, how does the culture surronding one platform or another affect the quality of the average developer on that platform, if at all?
3 Answers
Really interesting question. My personal opinion is that it's one that's asked far too often and really holds no water whatsoever.
Script kiddies (and companies that hire them) let the language of choice dictate their status amongst the echelons of "programmers". Good engineers couldn't care less about the language of choice, but concentrate on solving the given problems with in the most optimal manner (obviously optimal is a general statement and can be applied to many different factors). Whether this is C#, VB, C++, Python or hand written assembly, it doesn't matter as there's a clear benefit to using that technology to solve the problem.
So in short, I think it's more valuable to look at the complexity of problems that one solves on a regular basis as opposed to what language they use to solve them.
Just my two cents on the subject :)
- 17,585
Quality of code developed in each of these languages is based on these fundamental philosophies and less on the individual developers
Each language does have a culture around it, because each language was developed for a reason by someone with an agenda and an underlying philosophy to why their language was going to be better at something than what existed at the time was created.
Like religions, programming languages tend attract people that already have the same predisposition to the core principals and philosophies of the language creator.
Example on perceived Quality of Solutions
In one Microsoft camp you have:
The C# philosophy is that it is more purely Object Oriented, promotes more modern idioms and requires more knowledge to do it correctly and thus should provide more higher quality solutions. This is what draws people to it over VB.
In the other Microsoft camp:
The VB philosophy is I can quickly and with little knowledge or effort build something that will let someone click a button and do something useful and of business value, how it does it isn't so important. This is what draws people to it over C#.
Here are some tongue and cheek takes on languages and their philosophies:
Perl people tend to care about the exact opposite thing Python people care about.
Java people care about making money.
JVM languages ( Groovy, Scala ) care about the JMV and not about Java the language.
All the Microsoft specific languages (VB,C#,F#, managed C++) tend to care about making money on Windows.
Erlang people care about stuff everyone other people haven't needed to care about, and don't appreciate what they don't know.
Lisp people don't care about what anyone else thinks they care about.
What these groups care about shapes the language, its development and its community.
Philosophies change with experience and need
I adopted ASM and BASIC because in 1983 that was all you had. I wanted to write games and demos, those were the tools to do it. Mostly ASM for demos.
I adopted C and then C++ back when it was the only way to write things like 3D rendering and pretty much anything else that was space and time critical. It wasn't ASM so I learned it.
I adopted VB to make money, it was the closest thing to the Scala, Director, and CanDo development environments that I was accustom to on the Amiga. I agreed with the rapid development philosophy
I adopted Java early on to make better money. I made money with VB until 1999 and left it behind when Java 1.2 got stable and mature and the web had fully kicked in by then, I had 4 years of Java experience when people really started taking it seriously. I agreed with the write once, run anywhere in that the more places my code ran the easier it would be able to sell it. philosophy.
I adopted Python late in its timeline, 2005 because it scratched an itch that Java didn't. I needed to quickly write code to use some libraries that were only available in C and also I needed to do rapid webservice prototyping Python was quicker and less code to do the same thing in Java. Somethings went to production as Java some stayed Python, lots of stuff never made it into the wild. I agreed with its batteries included, single idiom philosophies as well as the others.
I adopted Lua when I needed to put a lightweight scripting engine in my C++ and Java programs. This was way before the JSR233 support in Java. I agreed with the embedding a fully featured scripting language that is easy to use should be simple Lua philosophy.
I adopted Erlang in 2006 when I started needing massive scalability and relatively painless multi-core execution on highly parallel problems and have cross platform execution. **I agree with its no shared state, message passing, immutable state philosophy.*8
I adopted Objective-C when I started needing to build OSX and iOS applications. I agree with its add just the right about of Object Orientation to C to make it better philosophy. Also to make better money.
I adopted JavaScript officially in 2009 because I agreed with the CouchDB philosophy and it uses JavaScript. Still don't like JavaScript when I have to deal with the DOM.
I still haven't officially adopted Lisp, but I am going to eventually! I agree with its Those who don't know lisp are condemned to re-invent it philosophy.
An interesting question indeed. It is one of those where you understand the answer at the subconscious level but strive to put it into words.
It is best seen as a causality loop.
The culture is responsible for the "ethnic" composition of the developers attracted to the platform. That composition in its turn defines the qualities of the "average" programmer. The quality of the developers now using the platform influences the culture or its perception outside which consequently has an effect on the developers coming to the platform or leaving it. The value of the "quality" changes as a result.
I've been trying to come up with specific rules but I find it difficult to generalize. We need to separately investigate each platform. A few observations I've made:
The speed at which a particular platform is developed, extended, improved has a direct correlation with the quality of the developers. The constant flow of new shiny features and tools attracts enthusiastic developers (which on the average are more capable of quality work) and repels conservative minds who are irritated by the constant learning effort.
The less limits a platform offers even at the cost of a higher risk to shoot oneself in the foot equally attracts enthusiastic experimental minds
The more complex the things are which one needs to understand and master in order to use the platform equally attracts resolved individuals and scares away lazy developers