The Converged Application Container


Just about everything I do in my job points back to a construct that is a foundational part of the modern enterprise IT organization: the application server. Now, when you say ‘application server’, thoughts immediately wander to Java. More specifically, folks tend to think about servers that support traditional Java EE applications and rightfully so. Over the past ten years, the predominant type of application server has been of the Java EE variety, and the industry has experienced tons of innovation in this area with more undoubtedly yet to come. But is the term ‘application server’ only applicable when we are talking Java?

The one-word answer to that question is ‘no’. While the strong association exists today thanks to a widely adopted programming model (widely adopted for many good reasons I should say), I cannot help but wonder what associations we will make with the term ‘application server’ three, five, or ten years from now. I say this because I believe we are going to witness interesting changes in the application server space. The rise of cloud and mobile along with the persistence of scripting and functional programming languages will, in my opinion, force radical evolution and innovation in the application server. Most importantly, the application server will transform into a converged container for hosting all manner of application types.

That’s right. The traditional, Java-centric application server is going to morph into a container that is much more multi-purpose than it is today. Of course, this is not going to happen without the advent of some key functional enablers. While impossible to list or event predict all of them, here are a few that I believe will be important in this movement:

1) Programming language/model normalization services: Before the idea of a converged application container can proceed, there will have to be some sort of translation approach built into the system. This translation system will be responsible for normalizing the different programming languages and models used by applications within the server. The normalization will have to be to some sort of common language (perhaps Java) supported by the server, but the idea is that this action will be mostly transparent to the application.

2) Functional composability: Due to the need to support a diverse set of application types, a converged application container will actually possess a wide-ranging set of capabilities. In pulling in these capabilities, it is not a stretch to say that bloat could become a problem. This bloat could surface itself via conditions such as excessive memory usage or large disk footprints to name but a few. In order to avoid this, the application container must be composable. That is to say, the container must be able to dynamically enable features it needs based on the application types that it is supporting. It is interesting to think about the role that OSGi may play in supporting this kind of approach.

3) Context-driven management services: Just as the functionality of the container must be built via modular composition, the management services it offers up must be right-fit and contextually aware. The application container must be able to enable and deliver the right set of management capabilities based on the applications it is hosting. Managing a mobile application can be markedly different than managing a traditional Java EE enterprise application. Since the same container may be hosting either type of application, it really needs to be able to offer up management interfaces that are appropriate to either. Just as with the functional set of capabilities, it must do this without suffering from bloat. In short, management capabilities must also be composable, and they must be contextually aware.

The idea of a converged application container may seem pretty far-fetched to some, but I truly believe it will be an area ripe with innovation for the next three to five years. Albeit just a select few, the above capabilities will play an important role in making the promise of converged containers real. Enough from me though! I’m curious to know what you think about this whole idea. Reach out to me on Twitter @damrhein and let me know!

Advertisements

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


%d bloggers like this: