Programming Languages and You


Tyler Treat posted a tweet:

Can we please get over this “we use hot language X” thing? I don’t care what nails you used to build your house. Just show me the house.

With respect to one’s employment, you have no choice but to use whatever programming language has been dictated by the top brass.

GitHub uses Ruby. WordPress uses PHP. Facebook uses PHP and HHVM. Joyent uses Node. YouTube uses Python. Twitter uses Scala. Docker uses Go.

For these companies, they have their own reasons why they chose language X over another.

However, this post is not about the pros and cons of each programming language.

Rather, there is a far more important issue to be settled: that of operations.

Alex Payne pointed out two types of programming levels: small and large. While he specifically mentioned scaling,

scaling involves programming + operations.

Scaling in the small

In a system of no significant scale, basically anything works.

The power of today’s hardware is such that, for example, you can build a web application that supports thousands of users using one of the slowest available programming languages, brutally inefficient datastore access and storage patterns, zero caching, no sensible distribution of work, no attention to locality, etc. etc. Basically, you can apply every available anti-pattern and still come out the other end with a workable system, simply because the hardware can move faster than your bad decision-making.

This is a great thing, actually. It means we can prototype haphazardly using whatever technologies we hold dear, and those prototypes will often take us farther than we expected. Better still, when we hit a roadblock, getting around it is trivial. Moving forward just means spending several minutes thinking about your problem and picking an implementation technology with slightly better performance characteristics than whatever you were using before.

Scaling in the large

In a system of significant scale, there is no magic bullet.

When your system is faced with a deluge of work to do, no one technology is going to make it all better. When you’re operating at scale, pushing the needle means a complex, coordinated dance of well-applied technologies, development techniques, statistical analyses, intra-organizational communication, judicious engineering management, speedy and reliable operationalization of hardware and software, vigilant monitoring, and so forth. Scaling is hard. So hard, in fact, that the ability to scale is a deep competitive advantage of the sort that you can’t simply go out and download, copy, purchase, or steal.

So back to the fuss over “we use hot language X” thing:

Regardless whether you are scaling in the small or scaling in the large, it does not matter what language you use because of my version of Pareto principle:

IT business is 20% software development and 80% operations.

However, at the individual level, it all boils down to personal preferences. As Brendan Eich said,

Syntax is user interface.

With that said, here are my preferences for programming languages:

  • no to class-based languages, yes to interface-based or prototype-based languages
  • yes to languages that treat functions as first-class
  • open source and has an active community
  • no to JVM-based nor .NET, yes to write-once, deploy anywhere
  • if I’m a newbie and need to learn only two languages, that would be JavaScript and Go
  • opinions are mine, no need for flame wars 🙂

Subjectivity aside, leave a reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s