Stalwarts in Tech – An Interview with Tim Fox – Vert.x and why it’s better than NodeJS!

About this series

This is the second interview in a regular series of interviews with stalwarts of the technology industry. We wanted to highlight many of the unsung heroes of the technology industry, the people and projects that have made huge impacts in our lives as developers and technologists!

Tim Fox – Messaging, Red Hat and the new Vert.x Application Platform

We’re really pleased to have Tim Fox from Red Hat to continue this series as he and Red Hat have been major contributors to Java and Open Source for many, many years. In particular Tim and his team have been responsible for Vert.x – a light-weight, high performance application platform for the JVM based on polyglot programming, asynchronous messaging and reactive programming principles. Phew! We’re really excited about Vert.x and its impact on the industry, and in fact use it as a core part of our technology stack here at jClarity. So without further ado, let’s find out about Tim’s contributions, his history with traditional messaging systems, motivations behind Vert.x and some deep dive details about this exciting new paradigm/framework!

1. Would you like to introduce yourself Tim?

My name is Tim Fox and I’m a software engineer at Red Hat. I’ve been doing software engineering for almost 18 years, the last 9 or so in open source. I am the founder and project lead for the Vert.x project. Before creating Vert.x I spent several years leading messaging development at JBoss – in particular creating the HornetQ messaging system, which is the messaging system at the heart of Wildfly (previously known as JBoss Application Server). I’ve also worked for a while at SpringSource.

2. You’re currently the Vert.x project lead. Can you tell us about what Vert.x is and what it does?

Vert.x is a polyglot asynchronous application platform for the JVM. That’s a bit of a mouthful so let me dissect it a bit.

  • Polyglot – You can create different components of your application in different languages – we currently support Java, JavaScript, Groovy, Ruby and Python and have beta level support for Scala, Clojure and PHP.
  • Asynchronous – Most things you do in Vert.x involve coding to asynchronous, non blocking APIs. This is to allow you to scale more easily with concurrent load which is very difficult to achieve if your application blocks.
  • Application Platform – Vert.x is a very general purpose platform which you can use for many types of applications – including web applications, in particular modern ‘real-time’ web applications, but also traditional ‘enterprise’ back end apps.

If you’ve already heard of Node.js then one way people sometimes describe Vert.x is “Node.js for the JVM”. This is true to a certain extent in that we have similar asynchronous APIs and we support JavaScript. But Vert.x does more than Node – we have features such as the distributed event bus in the core of Vert.x, and we are not only JavaScript.

Vert.x also has some overlap with platforms / frameworks such as Akka and Erlang/OTP – in that we have a similar architectural approach to application design and concurrency.

3. You created HornetQ and have worked on RabbitMQ, what motivated your transition from enterprise messaging to a more general framework?

Vert.x includes a distributed event bus, which is really a lightweight messaging system, so I haven’t completely moved away from messaging! But the Vert.x event bus does not attempt to provide some of the features usually found in Enterprise messaging systems such as transactions and durability. Also the Vert.x event bus is a peer to peer messaging system with no master.

So.. how did Vert.x start? While I was working at SpringSource I was looking at Node.js and I liked some of what I saw – the simplified, lightweight approach to application development, but I didn’t like other things such as being JavaScript only, and I thought we could do something similar but better using the JVM – a much better virtual machine. And if it’s on the JVM we could allow developers to use a whole range of languages, not just JavaScript. This seemed like a compelling idea and up until that point no-one else seemed to have thought about it. So I started hacking on a project in my spare time, which was initially called Node.x (with the x representing a wildcard – i.e. the polyglot nature of the project). The project started to get a lot of interest really quickly and people started to notice it, and it really just grew from there. Since then we have had a few imitators, but none (yet) have got the traction that Vert.x has.

4. How did your messaging background influence the design of vertx?

It’s definitely had a strong influence. A key architectural feature of Vert.x applications is that the modules communicate with each other by exchanging messages over an event bus, which is how people have been writing messaging based applications for years. Vert.x also takes inspiration from actor implementations such as Erlang/OTP. I’d say the three greatest influences on Vert.x are Node.js, Erlang/OTP and asynchronous messaging.

5. You’ve designed vertx to be polyglot from day 1, what design differences has this resulted in compared to frameworks based on a single language, for example Spring or Rails?

Creating a polyglot platform is quite a bit more complex than concentrating on just one language but it has the advantage of making the platform more attractive to a larger set of developers, it also means you can use different languages for different parts of your application depending on the skill-set of your teams, e.g. you might have front-end developers who already use node and client side JS, and back end developers who use Java/Scala more.

I suppose the main design issue with polyglot is solving how components in different languages talk to each other. Allowing direct method calls between different language components is fraught with issues, so we solved this by using the event bus for component communication rather than direct method calls, and we recommend JSON is used to exchange messages, as JSON is easily understood by all the languages.

6. There’s a few competing technologies in this space, notably node.js, Akka and Oracle’s recent project Avatar.  What does Vert.x offer over these alternatives?

As I see it, the main advantages of Vert.x over node.js are better performance (see the latest techempower benchmarks), not being restricted to just JavaScript, and the distributed event bus.

I have respect for the work the TypeSafe guys are doing on Akka and we are moving in a similar ‘reactive’ direction. I suppose I see the main advantage of Vert.x over Akka is that Vert.x is not just Scala/Java.

I don’t know too much about Avatar, but I believe it is a less general and more opinionated purpose platform than Vert.x.

7. Vert.x has recently moved to the eclipse foundation and is backed by Red Hat.  Do you foresee it penetrating the enterprise?

I would hope so, but these things take time for mass adoption. Most enterprises are notoriously conservative and lag behind the early adopters by several years. Having said that I know of a few large enterprises (I can’t name names!) who are already evaluating or using Vert.x.

There seems to be a real appetite for the new breed of ‘reactive’ application platforms right now amongst the ‘smart users’/early adopters, and I think this will eventually trickle down to the conservative enterprises and reactive will eventually become the new ‘enterprise’ rather than traditional JavaEE-style solutions.

8. We’re a performance tuning company, so we’re always interested in the performance characteristics of new frameworks.  Have you analysed vertx’s performance and what can you say about it?

Vert.x and Netty (which Vert.x uses) are already highly tuned for performance. We are lucky enough to have Norman Maurer as a core member of the Vert.x team. Norman is also a core member of the Netty team. We’ve spent quite a long time tuning both Vert.x and Netty (well, to be fair Norman has done most of the work) and we know that Vert.x is currently one of the very fastest frameworks/platforms out there.

9. Is there anything else you would like to mention?  Do you have a blog or twitter account?

I do have a blog, but don’t use it very much these days (too busy!). My twitter account is @timfox. There’s also a Vert.x project twitter account @vertx_project

=============

Once more we’d like to thank Tim for his detailed and thoughtful answers and encourage all of you to give Vert.x when you consider your next application!

Cheers,
Martijn (CEO) and the jClarity Team!

Say goodbye to Java performance problems!

No more memory leaks and application pauses!

Recent Posts