Empirical Analysis of Programming Language Adoption [pdf] (2013)
sns.cs.princeton.edu
Empirical Analysis of Programming Language Adoption [pdf] (2013)
1–10 of 21 posts
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#2Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#3The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself.
Also, at least among the studied population of developers interested in creating SaaS, programmers appear to be far more interested in the ease of bundling together other people's work to get something built quickly and cheaply than they are in features that would promote attributes like robustness, security, performance and scalability.
This may be due in part to a generally low standard of education and understanding. Many developers indicated a desire for characteristics like good performance and expressive power, yet then placed little emphasis on language features that could actually achieve those things, and a lot of them didn't even understand the most basic properties of and relationships between some of the language features they were commenting on.
The most positive observation to me is that there remains a long and heavy tail in most of the results, meaning objectively better languages can become successful within a niche even if they aren't widely appreciated and may never make it into the very small group of languages that dominate mainstream software development.
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#4The observations in this paper mostly seem to back up reasonable, yet rather depressing, assumptions we might have made. The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself. Also, at least among the studied population of developers interested in creating SaaS,…
But honestly you may not be in such a privileged position relative to the rabble, and there may be situational reasons for others not to want the features you want.
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#5The observations in this paper mostly seem to back up reasonable, yet rather depressing, assumptions we might have made. The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself. Also, at least among the studied population of developers interested in creating SaaS,…
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#6The observations in this paper mostly seem to back up reasonable, yet rather depressing, assumptions we might have made. The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself. Also, at least among the studied population of developers interested in creating SaaS,…
There is only one question that matters to developers: Is this productive?
By that measure, the language itself is a small part of the equation which includes tooling, libraries, community, documentation, etc etc etc. This is completely normal and not depressing. It's sane.
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#7Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#8The observations in this paper mostly seem to back up reasonable, yet rather depressing, assumptions we might have made. The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself. Also, at least among the studied population of developers interested in creating SaaS,…
the size of the surrounding ecosystem
I think you underestimate the importance of this. Particularly if you have a complex and multi-faceted problem domain at hand, ecosystem and library support can be a dealbreaker, for which many people would sacrifice expressiveness and language power. Particularly so if the language is relatively malleable and/or dynamically introspectable, so they can sort of emulate certain higher language features just enough to be useful, while having abundant libraries, toolchains and documentation. It's definitely a valid trade-off.
In addition:
programmers appear to be far more interested in the ease of bundling together other people's work to get something built quickly and cheaply
This is primarily a side effect of software complexity. Starting off from first principles can be quite impractical these days, so stitching together others' work is becoming a common paradigm. I'd almost say it's the natural end result of abstraction itself.
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#9I've known some engineers to argue that the number of languages on a CV is negatively correlated to the quality of the candidate.
Re: Empirical Analysis of Programming Language Adoption [pdf] (2013)
#10The observations in this paper mostly seem to back up reasonable, yet rather depressing, assumptions we might have made. The choice of programming language for a project seems to be driven primarily by the size of the surrounding ecosystem and developer familiarity, rather than by any sort of technical merit in the language itself. Also, at least among the studied population of developers interested in creating SaaS,…
Instead of expecting people to change their taste and demanding re-education, find a way to give them what they want while also giving them what you think they should have. But honestly you may not be in such a privileged position relative to the rabble, and there may be situational reasons for others not to want the features you want.
I don't really expect them to change their taste. As I said, the actual situation is something we might reasonably have guessed: combining building blocks quickly and cheaply is perceived as more important than quality. Given that it's clear a lot of people will pay for cheap junk, that is a commercially sensible thing to produce.
I just find it sad that this is the situation we seem to have drifted into. As more and more things we use every day depend fundamentally on software, and an ever more connected society makes issues like security and scalability more important as well, I think the world would be a much better place if consumers were less forgiving of problems caused by badly written software and demanded better. However, the industry seems to have succeeded in convincing most people that mediocrity is inevitable and software that only works for a brief period or requires constant updates for maintenance is the norm.
What is perhaps more sad is that so many professional software developers themselves don't seem to know any better.
For example, part of this study examined attitudes to static typing and unit testing. We might reasonably suspect that a population interested in SaaS has a bias towards dynamic languages like Ruby and Python, so it's not too surprisingly that 62% said they saw the value of unit testing compared to only 36% for static typing. The disturbing thing is that both of these figures are so low, given that these aren't exactly controversial techniques and there is plenty of evidence that using at least one of them can substantially improve quality.
Another telling contrast was that when asked about what they enjoyed using, programmers heavily favoured expressive languages, yet when asked about which language features were important, features that offer more expressive power like templates, generators, higher order functions and macros were all rated much lower than OOP staples like classes/interfaces and inheritance. A majority saw little if any connection between higher order functions and objects, despite their mathematically provable relationship; a third didn't even understand the question.
When you have that level of ignorance of programming theory that really ought to be general knowledge by professional standards, it's not really about letting developers have what they want while also giving them what anyone else thinks they should have. They could already have both today, and they already say they want the benefits that would bring. They just don't know enough about the tools that are already available to them to get those results, and isn't that just a straightforward education problem?