Compiled vs. Interpreted Languages: Which Is Better for DevOps?

In the age of DevOps, programmers are encouraged to prioritize speed, agility and visibility. In many respects, interpreted programming languages would seem to offer an advantage in this respect over compiled languages. In fact, you might argue that DevOps could eventually lead compiled languages to become obsolete.

Is that an overstatement? Let's explore the benefits and drawbacks of interpreted and compiled languages for DevOps programming.

Advantages of Interpreted Languages for DevOps

Interpreted languages--meaning those where source code is fed directly to an interpreter at the time of execution, rather than being compiled ahead of time--offer several benefits from the DevOps perspective, including:

These advantages help to explain why Python, which originated in the late 1980s as a language primarily for boring system-administration tasks on the Amoeba operating system, has grown into a full-fledged, general-purpose language that runs almost anywhere. You could draw similar conclusions about Ruby, another popular interpreted language designed to improve accessibility and readability at a time when many other languages lacked these traits.

These languages originated before DevOps emerged in the late 2000s, of course. But I suspect that part of the reason why they remain so popular today is that they happen to be excellent programming languages for DevOps.

Compiled Languages and DevOps

All of this is not to say that compiled languages are useless in the context of DevOps.

Compiled languages still retain their biggest advantage over interpreted ones: speed and performance. Although modern interpreted languages perform quite well (which was not the case decades ago), in most cases applications written in a compiled language will still run faster and consume fewer resources. For DevOps teams concerned with efficiency and user experience, then, compiled languages offer at least one important advantage.

Some compiled languages that have debuted in recent years, such as Go, also lend themselves particularly well to modern application architectural and deployment strategies, like microservices and distributed environments. That's not surprising, given that these languages were designed in an age when these trends were already becoming important. But it does give them an advantage over the mainstay interpreted languages, most of which originated decades ago and were not designed with modern deployment techniques in mind.

Conclusion

So, which type of language is best for DevOps?

The answer depends on what matters most to you as a programmer. If having a modern architecture and optimizing the performance of your application is your greatest priority, a compiled language will probably be the best choice for you.

However, if having agility and visibility within the continuous delivery process is more important, interpreted languages are an overall better choice for DevOps programming.

Because both types of language have their advantages and drawbacks, I don't think we should expect one or the other to disappear anytime soon. But I do suspect that, as long as we continue to live in a DevOps-dominated world, interpreted languages will only grow in popularity.