Untangle the Bad Parts

TL;DR. This is a subjective view and must be put in context of how things in IT should work that are simpler, better, faster and more importantly, keep you sane.

In the pages of history, you will see technologies that rise, thrive and still survive in spite of the emergence of more nimble and much better technologies.

Take the case of Java.

In our view, Java must decrease in influence and usage among the IT community. Java has proved its worth. Steve Yegge has already ranted about it way back in 2006. And yet, up to this day, companies are still looking for Java skills as if there are no better alternatives.

There are better alternatives like Scala, Clojure, Groovy and whatnot.

But I’m not here to trumpet the virtues of Java nor its Java Virtual Machine (JVM).

I am here to decrease the JVM tentacles in IT.

AOCT

I am not saying “Do not use JVM”.

What I am saying is that you have to use suitable software for the job.

In the case of microservices, you are better off with a smaller runtime.

So for newbies, here is the historical evolution:

  • Machine languages — 0 and 1
  • Assembly language — portable machine language
  • C — portable assembly language
  • Compiled languages — program against an OS (Go, Rust)
  • Interpreted languages — program against the runtime machine (Python, Ruby, JavaScript, etc)
  • Java — program against the JVM (same with Erlang)

Before, you used to program against a single machine only. It is simple.

With the N-tier nature of microservices, it is now a distributed system.

Sure, you can distribute the runtime software on separate physical or virtual machines. You need configuration management tools to get the job done.

That was and is the case up to now for physical/virtual machines.

There is nothing wrong with that.

The problem becomes when the world shifts to another paradigm. That of containers.

Of course, physical/virtual machines are going to co-exist with containers but the former will decrease in favor of putting more and more containers or application machines to physical/virtual machines.

That is not hype. That is the trend and will continue to increase because it is more nimble. I hate to use the word agile. You have to dump that word just as the word DevOps is meaningless.

In a few words, this is what we are seeing right now:

  • Compiled languages (like Go and Rust) make for a small binary that is fast to build and deploy
  • Interpreted languages are not going anywhere. They are just relegated to analytics like MapReduce, ad hoc queries and more conducive for data-related tasks owing to its dynamic typing.
  • JVM and JVM-based languages are anti-patterns with respect to microservices. It defeats the very purpose of microservices that should be small and fast enough to be moved around.
  • Docker (the container runtime) rises to become the ubiquitous platform for distributed systems. Just as compiled languages make way for static binaries (that are nimble to build and deploy), Docker make way for containers as alternative to 1) apps that are tightly coupled to operating system and 2) scripts that are tightly coupled to its respective runtime.
  • Use Go for microservices

ASMALLIn short,

For microservices, do not use languages that produce bytecode. Use compiled languages instead. Then and only then can you fulfill the promise of containers as “build once, deploy anywhere” without the bloat

Advertisements

Subjectivity aside, leave a reply

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

WordPress.com Logo

You are commenting using your WordPress.com 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