I was at DevoxxUK last week on a panel session about the future of Java EE (my thanks to Antonio for inviting me). I suppose it wasn't surprised that you had all of the panel members united in their view that not only has Java EE been good for the enterprise middleware space, and of course it has a future role to play in areas such as cloud and IoT. It wouldn't be too hard to suggest that the panelists weren't objective in their assessment but that would be too easy and overlook the reality: Java EE has been the most successful cross-vendor enterprise middleware standard we've ever known; of course it's not perfect; of course there have been a number of iterations required to improve its applicability to an ever evolving set of use cases. But warts and all, Java EE implementations such as EAP have been deployed widely across the globe and sit at the heart of many of the mission critical environments we take for granted, such as banks, hospitals, air traffic control systems.

I've been around the proverbial block long enough to appreciate the incredible amount of technical work that has gone into Java EE and J2EE before it. But what I appreciate more, and what some people are too quick to ignore, is the incredible amount of cross-vendor/cross-community agreement that has gone into these standards. We often take for granted how well, on the whole, open source developers can collaborate under the banner of a single open source project. However, until relatively recently open source was not a main source of collaboration for Java EE. Even then, working within standards bodies can be a long, slow process, fraught with the usual tensions of getting agreement on interfaces, behaviours etc. when there are already multiple competing implementations for this or that feature. And the amount of time and effort this takes is often proportional to the number of participants. Take a look at how many people have worked on Java EE over the years and marvel at what they managed to achieve, whether or not you agree with it all.

As I've said many times in the past, the principles on which Java EE are based are pretty common to distributed systems in general. CORBA has them. DCE before it. Countless bespoke implementations both before and after, as well as currently, need some or all of the same capabilities you find within Java EE. With the new generation of EE implementations, such as EAP, which are agile, small and extremely fast, getting access to high performance messaging, bullet proof transactions, or something else by using EE is easier than many people believe and often easier than some of the new generation of frameworks in Java or other languages.

Back to the DevoxxUK panel: during the event several people in the audience expressed their agreement with the assessment that Java EE has a future, or at least should be allowed to aim for one, but that they were surprised this was the first time they were hearing from the vendors and communities represented by the panel that they were willing to work together to try to assure that future. I suppose on the one hand we've all felt that actions speak louder than works, and the fact that we've all been working together for years on the betterment of Java EE was assumed to be sufficient evidence that we'd continue to do so - are continuing to do so. However, given rumours and other concerns about the future of Java EE, I can certainly empathise with developers who want to hear that the major vendors are standing behind it. Well Red Hat and those on the panel at DevoxxUK hopefully made it clear: we are prepared to continue innovating with and on Java EE, and it's a key part of our strategy.

No one starts out wanting to build a monolith. There are no design meetings where the architect or developers say "you know what? I think it'd be a great thing if we built something that will be hard to evolve and maintain." I think it's also fair to say that conversations like "we've got a great architecture for our system that has helped us be successful, so we need to be sure that it evolves towards a big ball of mud" rarely happen!

And yet monolithic applications do exist. Probably less than many people might want to admit, but they are there nonetheless. So the question has to arise: why? I suppose there's another related question: how? As with so many things in this life, there's no one straight answer; it's a combination of things including:

- Expediency; far too often it's just too easy for developers to hack solutions into an otherwise good architecture without spending time to understand whether that breaks the architecture. What starts as a simple, small hack can also then grow, acting as a catalyst, and a small break in the architecture then turns into a fracture.

- Lack of architect (leadership); the original architect(s) leave the project and those who come in to replace them (if they are replaced) can't control the developers or perhaps don't understand the architecture enough to ensure it remains "pure". Likewise, different developers coming into the project to either add to or replace those there already, can dilute the group knowledge and understanding of the architecture, leading to unforeseen and accidental divergence from the original plan.

- Natural evolution; any system than can be said to be architected has a point at which it's simply impossible to evolve and retain the original architecture. Take a look at any (historic) building which may have once been considered an architectural marvel and if it was left mainly alone (not extended) once complete then it's likely still something to behold and admire. But if it had extensions, new wings etc. then it's likely to be a monstrous carubuncle, unless the original architect was involved, or someone who appreciated/understood the original. Sometimes it's just easier to start from scratch and approach the problem afresh, than try to tack on new features.

- Related to the above, sometimes people try to extend software systems (services) to do more than they really should and in doing so break the architecture or create monoliths.

- Poor tools with which to visualise the software system/architecture, leading to making it harder to track changes and ensure they don't move the system towards an unmanageable monolith.

Now nothing I've mentioned so far has been specific to localised applications. It's just as applicable to distributed systems and in fact in a distributed environment the architectural issues can become even more important to understand and track. If you've arrived at a monolith then trying to fix that may involve breaking it into components/services/microservices which reside in a distributed environment, but that's not necessarily the only way, or the best way, in which to resolve the monolith problem. In fact if you don't understand the architectural issues which have resulted in the monolith then breaking it into components is more likely to result in a distributed monolith (or micromonoliths) than to fix the problem!

Yes, I mentioned the microservices word above for the first time and this is really an article about them again. As I've mentioned elsewhere, I believe in and understand the need for distributed systems composed of (micro) services. However, what worries me about some of the current emphasis around microservices is that somehow they will naturally result in a better architecture. That's simply not the case. If you don't put in to place the right processes, design reviews, architecture reviews, architects etc. to prevent or forestall a local monolith then you've no hope of achieving a good microservices architecture. And if you don't keep them in place then there's a good chance you'll evolve towards a distributed monolith.

I've been designing, developing and otherwise involved in distributed systems for 30 years. I love the challenges they present, especially around my own speciality of fault tolerance. Whether it's different consensus models, the duality of orchestration and choreography, replication techniques or different transaction models, to name but a few, working with distributed systems is thought provoking. And in today's world of ever connected devices at scale, it's even more so than at any time in the last decades.

There are many good architectural reasons why you might want to, or need to, employ a distributed approach to your application. Code you rely on may be running elsewhere to your own business logic, may be implemented in a different language, or may need to be replicated to improve availability, for instance. It may even be the case that your distributed system evolved over time from a more localised implementation, e.g., a capability you wrote now needs to be shared between groups and it makes sense to replicate copies physically closer to them.

Distributed systems make a lot of sense for many applications and developers. In the words of RFC2119 they MAY help to solve some particularly tricky issues but they WILL cause other problems of which you MUST be aware. Distributed systems are great. But you know what? A centralised system may be far more appropriate for what you need. Why do I mention this and why do I think it's important that developers and business owners realise this? Because if you listen to our industry at the moment you'd be forgiven for believing that all applications need to be decomposed into (micro) services, each residing in its own (Linux) container and communicating using HTTP (hopefully at least using REST too).

If you've got a centralised system that doesn't mean it's necessarily a monolith. Likewise distributed systems aren't necessarily more agile, lean or less monolithic in nature. As a developer, architect or business owner you shouldn't feel ashamed to admit "I'm centralised and I'm proud!" Don't feel that microservices are going to solve architectural problems due to their distributed nature and if they do, they will definitely introduce challenges you don't have to worry about in a local environment. Now don't get me wrong, I appreciate the ideas around microservices as they are influenced by SOA and other experiences over the years. Unfortunately some of those who are pushing microservices strongly fall into one or more of the following categories: they don't care to learn about distributed systems, they don't believe they have the time to learn about the pitfalls of distributed systems (our industry moves at a pace), they have an agenda which isn't necessarily conducive to your productivity, or maybe they really do believe they're doing the right thing by adopting these new fangled ways. And of course there are proponents of microservices architectures who really do understand the trade-offs they represent and will faithfully represent them to you so you can make an informed choice.

Furthermore, citing examples of successes such as Netflix or Amazon is hardly being fair to the large numbers of applications and vendors who don't use distributed systems, let alone microservices, and would still consider themselves to be successful. Of course there are things we can learn from the likes of Netflix. Of course there are lessons we can apply when considering microservices. But just because you are developing a centralised system does not mean you are a failure or should be consigned to the garbage can of history!

Alright, if you've read this far you would be forgiven for thinking I don't like microservices. But you'd also be missing the point. Just as we've been shown over the years that writing distributed systems is often necessary and a core requirement for some applications, so too is developing using a microservices architecture. What I'm trying to show though, is that you'd better understand why you need to distribute your services as well as the fundamental implications that such an approach entails. And maybe, just maybe, going back to, or remaining, centralised is really the right thing for you.

For many many years the Java world has popularised frameworks for developers. Most developers understand that frameworks sit on top of stacks and typically act as a way of simplifying the interaction with the complexities that exist within. Experienced developers have long been able to build complex systems without frameworks but it has often been at the expense of time and reliability (some definition of efficiency). The best frameworks are extremely prescriptive, taking the plethora of configurable options which are presented to the developer by the combination of software components that make up the stack and narrowing them down to a very specific subset. They take the complexity and flexibility and condense it down to something which more than 80% of developers will find useful or easy to get to grips with.

Now that's not to suggest that this complexity and flexibility is bad. Far from it: one size rarely fits all and whilst one developer may not understand why it's even necessary to have an option to tweak Widget XYZ, another developer would find it impossible for that to not be available. Component developers have always tried to provide 1001 options for the wide range of users they can perceive and that's the right thing for them to do. However, many component developers are unable to consider how their implementations may be best tailored for the majority: in fact it may be anathema to them to do so. In some ways I speak from experience with our experiences around Arjuna! It's only in recent years, with the STM implementation, that I think we've managed to provide a framework that hits most of the user needs.

But I digress. This is not meant to pit framework developers (or users) against component/stack developers (or users). As software developers we need them both. However, in some areas, and it seems specifically in the Java space, we often hear about the frameworks more than the software entities upon which they rely. I suppose it's similar to movies: we hear more about the actors on screen than the plethora of people behind the camera who actually make the films possible. Another analogy might be the iceberg, where the majority lies below the ocean surface! This is a problem I've run into many times over the years and written about a few times. I'd put myself more firmly into the component/stack category of developers, though I've tried to learn from some of the more successful framework implementations and developers when coming up with the Narayana STM solution. Having many of those framework developers on my staff has helped, so it's probably an unfair advantage I have over others! However, my main point in writing this entry isn't about me or what I've done, it's about how frameworks and components/stacks exist in a symbiotic relationship: frameworks need the stacks on which they are deployed, or they have nothing to make them work, and likewise the stacks need frameworks if their capabilities are to be made readily available to a wider range or developers.

What "gets my goat", as we're used to saying in the UK, is that some framework developers are often less than up front with the fact that their offerings are critically dependant on the stacks "below". Don't get me wrong: I'm not making any judgement about the relative importance of the framework versus the stack in the final solution. However, I do believe in credit where credit is due. Now the users of frameworks are excused from knowing too much about what is happening under the covers: it's like driving a performance car and not knowing the details of who designed and built the engine; but at some point you do need to know that what makes a car perform is at least as important as how it looks! Despite the fact I work for Red Hat and am JBoss CTO I'm trying to be objective here. We've made some really good frameworks that build on our stacks. We've also been less than successful on others. Likewise some of our partners or competitors have made some great frameworks that also rely on JBoss components. The right framework can make you incredibly productive. But the right framework also needs the right support from the components and stack upon which it is deployed. If you don't have a good framework but do have a good stack then a good developer can still be productive but not necessarily efficient. If you have a good framework but a poor stack (e.g., not reliable or scalable) then a good developer is going to realise quickly that all that glisters is not gold!

OK so you may well ask what's the conclusion? First of all I'm not sure there's just one conclusion. If you're a developer then of course you're going to look for the framework that makes you the most productive (definition: get done what's needed in the shortest period of time, but ensuring when you move on to your next company or project you don't leave a steaming pile of poop for someone else to pick up). These days we're a wider Java community that focusses a lot on the implementation language and the framework, since they typically go hand in hand. Projects often have tight deadlines and aggressive milestones making it easy to justify selecting your approach based on the experiences of others who may also have been subject to tight deadlines. But ultimately we need to take the time to investigate the entire solution not just the framework because one really can't succeed without the other.

I've written before about the way I think the next generation platform will evolve. Here I want to take a moment to suggest how this might be approached in the future within Red Hat middleware, using JBoss, Fuse and other technologies including Vert.x. I suppose if I were working for any other company than Red Hat I might have to say that there are some disclaimers about my opinions being my own etc. However, whilst they certainly are to a degree, because we're doing this in open source you can see what we're doing and even get involved yourself!

Of course microservices are the future. Ok, maybe there was a hint of sarcasm in that last sentences! Microservices have a role to play, just as SOA does (yes, I still believe the two are closely tied). There is some truth in there though: more streamlined, agile and dedicated services will be the basis of future application development, whether using (immutable) containers such as Docker or just the standard JVM, perhaps with fatjars. However, anyone who believes that the future of software (middleware) will appear instantaneously has obviously not looked back at other transitions, such as bespoke-to-CORBA or CORBA-to-J2EE. These things take time and evolution rather than revolution is the natural approach. Even if you've not been involved in middleware there are similar examples elsewhere in our industry: COBOL really is still in deployment today! Look at the interest we have around Blacktie!

Therefore, the future will evolve. Yes people will want to develop new applications (so called greenfield sites) using the latest and greatest framework or stack. But they'll also want to integrate with existing business logic and services written in a variety of present day technologies. So there'll still be Java EE application servers (e.g., EAP) with business logic within them, some of it legacy, some written from scratch today and into the future, despite what some may believe.

I believe that due to the fact Java EE has been the dominant non-Microsoft development and deployment platform for well over a decade, there are so many developers out there who are comfortable with it. Yes some may complain about the apparent bloat of implementations, but the reality is that it's still very easy to develop against and use from a variety of different programming languages. That's why the evolution towards any new paradigm is going to be heavily influenced by it, if not driven directly by those developers. So yes, I believe that microservices and Java EE go hand in hand for a large percentage of developers. Approaches such as WildFly-Swarm offer precisely what I'm describing: a comfortable entry point for developers and even existing applications, yet the power to move to a more flexible DevOps driven paradigm. WildFly, when used correctly, offers a mature and easy to use platform that has a minimal footprint and faster boot times than the most popular web servers around! And don't forget that Swarm builds on WildFly so we immediately get the maturity of implementations(s) from it.

However, this mad rush towards microservices, trimming of application servers, creation of applications from fatjars etc. needs to be approached with caution. Our industry is renowned for offering panaceas to problems that require throwing away all we've done before and relearning all of those hard earned lesson! We've got to break that cycle and in Red Hat we've got the pieces to do so: with so many open source projects out there purporting to be right for enterprise applications and new ones springing into life almost on a daily basis, it's easy to understand why people believe every new project is good enough for their requirements. Although I believe open source is a superior development methodology, it takes time and effort to build enterprise-ready components such as transaction servers, messaging brokers, etc. They don't just spring into life ready formed and fully capable. "Good enough" is rarely sufficient for enterprises. It's the edge cases like management, reliability, recoverability, scalability and bullet proof security that are hard to do and get right, yet it's precisely those edge cases that matter time and again. Through core development or acquisition, we've built up a stack that is mature and capable. Whether deployed as a stack or individual pieces, it's what we should be building the next generation of middleware solutions upon. A strong base exists today and we need to reuse as much of that as possible rather than rewrite from scratch in some new popular programming language.

Now as I hinted above, maybe we don't package our future stack or platform in quite the same way as we do today. Microservices offers an approach that is in line with the kinds of trimming we've been seeing anyway. Bundling individual components from the application server as easily deployed (container based) services that can then be exposed to other programming languages, frameworks, solutions etc. is definitely part of the overall solution space. Those core services, such as transactions or storage, could be deployed as individual services or, as is more typical with something like Swarm, deployed with the business logic that uses them. I keep coming back to the JBossEverywhere initiative we had a few years ago - ahead of its time!

Ok so we've looked to microservices and how Java EE fits in. But that can't be the entire answer - and it isn't. As I've mentioned before, at least for a very important set of applications and use cases the future is reactive and event driven. Now that could mean Node.js but just as likely in the Java world it probably means Vert.x. Note, given that many of the Java EE APIs aren't reactive or asynchronous in nature then we'll need to evolve them if we wish to tie them in to Vert.x and I do think we need to do that. Whilst some people will want to develop their applications and microservices in Vert.x from scratch, others will want to tie in legacy systems or have access to some of the core services I mention earlier. I see Vert.x as the ideal backbone or glue that brings all of these things together. The mature core services that we've got are precisely the sorts of things that enterprise developers will need for their applications as they grow in complexity - and let's face it, eventually many applications are going to need security, transactions, high performance messaging etc.

In the Java world the unit of containerisation is essentially the JVM. However, most Java developers realise that unless you ship a farjar, which contains everything you need to run your application/service, it's often typical to find that changes in third-party jars downloaded at deployment time can result in the application or service failing to run first time. This is where operating system containers, such as Docker, really come into their own. The ability to create a deployment unit which runs first time and every time is crucial! Container orchestration technologies, such as Kubernetes, are likewise important if you want to deploy services (via Containers) which are highly available, load balanced etc. Therefore, hopefully it's not too difficult to see where Containers will fit into the future architecture - not mandatory by any means, but definitely a piece of the puzzle which should be considered from the outset.

The combination of OpenShift for Container deployment and management, with Fabric8 for developer experience with CI and CD, provides a compelling hybrid cloud environment, especially once you consider all of the JBoss/Fuse middleware integrated, i.e., xPaaS. As I've mentioned before though, xPaaS isn't about simply adding the middleware products to OpenShift; we're also going to make them much more cloud-aware/cloud-enabled. This has a number of implications, but the one I want to mention specifically is that the core capabilities will be made available to developers in a more cloud-natural manner, e.g., users who want reliable messaging won't need to understand the various intricacies of JMS to use A-MQ and in fact won't even have to know A-MQ is working under the covers. And yes, for those of you still paying attention, those core capabilities I mentioned are precisely the same core services we covered earlier on. See the connection?

Up to this point we've really been playing in the traditional enterprise deployment arena: clients, middle tiers and servers. The cloud comes into play here at the back tier (servers), but what about mobile, IoT and ubiquitous computing? I've discussed this a few times before so won't repeat much here except that I think everything we've discussed so far has immediate applicability for ubiquitous computing and that mobile, as well as IoT, are just limited aspects of it. In fact as I showed separately, if the cloud is to scale, mobile/IoT needs to take on a more fat-client approach - anyone remember what I wrote about Shannon's Limit over 4 years ago? Mobile, which really means developing applications for phones that tend to rely upon backend services, is a specific implementation of IoT, which really means developing applications for a range of devices that tend to rely upon backend services (ok, with some gateway technologies in there for good measure.) See what I mean?

If you follow that assertion that everything we need to do going forward is some aspect of ubiquitous computing, then it follows from what we discussed earlier that the new stack approach of core services, Containers, management etc. all come into play and across a variety of different languages and frameworks. Whether you're developing enterprise applications for mobile devices, clouds, involving sensors, or traditional mainframes, you need a stack that is mature, rich, scalable, reliable, trustworthy and open. The Red Hat stack, which has evolved over the last decade and is continuing to evolve, is the only one that matches all of the requirements!

Below is a hand-drawn outline of where I see these things going. Apologies that it's not a nice block diagram and for my handwriting

Only a few years after the rise of public Cloud (essentially after a certain online bookshop offered its services to the public) I recall a number of people talking about how open source would no longer matter. The argument, which from 39000 feet made some sense, went something like this: people use open source because closed source equivalents are too expensive, often too difficult to use and generally just a way of accomplishing something "good enough" in a cheaper way. Because cloud offered capabilities, such as web server, messaging, storage etc. to developers on a pay-as-you-go basis, what did it matter if under the covers the implementations were based on closed source or open source? Therefore, people wouldn't approach developing solutions in the cloud by even considering the provenance of the underlying components.

Now of course even at that time you could argue that the argument didn't hold water at all levels. Specifically the operating system back then was predominately Linux based, which last time I checked was most definitely open source. In the intervening years we've seen Microsoft enter the space and whilst Linux is no longer the only operating system available in the clouds it's definitely still the dominant one. But that's not the only thing to change which drives a tank-sized hole in the original position. Today in all public or private clouds you don't have to look hard to find open source making it a reality. Whether it's OpenStack as the infrastructure, databases such as MySQL or MongoDB providing persistence, A-MQ or RabbitMQ for messaging, EAP/WildFly or GlassFish or Tomcat hosting some of the business logic, open source is integral to the success of public, private and hybrid cloud. Obviously there's a chance a developer may not know or even care that open source is responsible for the success of their application or business, but that doesn't negate the fact that cloud is successful today primarily because of open source.

There's also one important aspect that the original argument failed to take into account: users of open source are just one part of the overall value proposition; contributors/developers of open source are just as important. When you look at all of the examples of open source used in cloud I mentioned above, or go further and look at all of the others, you'll see that as well a individuals helping to develop these critical software pieces you've got pretty much all of the significant software vendors of our age as well as many of the most significant software users (verticals such as finance and healthcare, not to mention NASA).

Not exactly related to cloud, but when you get a company such as Microsoft making such an about turn on open source as they've done in the past year or so then it's probably a good bet that open source isn't dropping down the list of priorities for developers or companies. Therefore, to paraphrase and misquote Mark Twain, I think it's safe to say that reports of its death have been greatly exaggerated.

An interesting comment to an entry I made the other day got me thinking about "web-scale". It's a term I may have used. I know others have too. Yet WTF does it really mean?