I am currently the lead of the JBoss Application Server project. I am also a member of the JCP, and represent Red Hat on the future Java EE6 specification. During my tenure at JBoss, I have worked in many areas including the application server, clustering, web services, AOP, and security. My interests include concurrency, distributed computing, hardware and programming language design.

Location: Madison, WI
Occupation: Principal Software Engineer at JBoss, a division of Red Hat
25. Jul 2011, 17:51 CET, by Jason Greene

The short answer is that it is designed around Ahmdahl's law (effective parallelization of work) as opposed to Moore's law (waiting for hardware with a faster clock rate). Almost every CPU powering desktops, laptops, and servers is now at least dual core, and the trend is rapidly expanding. The days of the frequency race are essentially over. So, now software must adapt to tap into the power of the hardware of today and tomorrow.

JBoss AS underwent an aggressive transformation to achieve this critical evolution. With AS 7 we started from scratch and built an entirely new, highly performant, and manageable core architecture from the ground up. With some truly amazing engineering effort we were able to go from a tiny prototype on github, to the full blown Java EE Web Profile compliant container of today in a little over a year (not to mention that during all of this we also delivered AS 6 which allowed JBoss users early access EE6 technology).

Before explaining, allow me to provide some background. The core problem an application server is tasked with is managing services. Nearly all components in a modern application have some kind of life-cycle, meaning that there is some point at which it must be started, and some later point at which it must be stopped. We label anything that has a life-cycle a service. Another important property of a service is that they typically have relationships that impact their respective life-cycles. As an example, we might say that a servlet's service depends on a web server. In addition we would probably say that if that servlet uses some other resource like a database connection or an EJB that it depends on those being being available as well. When an application server starts or deploys it must make sure that it starts all of the various services in the correct order. Further if any of these services are somehow stopped, it must stop all dependents first (essentially reverse order). This is a fairly simple problem when this is done in a single thread.

JBoss AS 7 on the other hand starts and deploys all services in parallel. This complex problem is solved by our new service container, the JBoss Modular Service Container. MSC is essentially an advanced concurrent state machine. It analyzes the dependencies between all services on the fly and attempts to start as many as it can at the same time, while still adhering to the relationship requirements. This means that not only is startup blazing fast, but you also now can deploy multiple deployments in parallel.

In addition to parallel services, JBoss AS 7 also has modularity and concurrent class loading. By segmenting classes into proper modules, the app server can naturally optimize access patterns, and only look in the spot that truly owns the classes. Also, since the visibility between modules is intentionally limited, searching is cheap. In the case of JBoss Modules, module resolution and class lookup are O(1). All of this has a very high degree of concurrency, even a significant portion of class definition.

Deployment processing is also very efficient. One major optimization is that we index annotation information by quickly scanning a subset of the class file data. For even greater efficiency we allow modules the ability to pregenerate a space efficient index which is designed to be loaded very quickly. Yet another deployment optimization is that we carefully cache and reuse reflection data, since the JVM is not very efficient at doing so.

Finally the last major reason I wanted to highlight is that we have and will continue to be very militant about our CPU and memory usage on the start and deploy path. This is all about making good choices starting at the design phase. An interesting example is our moratorium on using JAXB (or any other introspection driven binder) to parse configuration that is only read once. It ends up spending the same or more time figuring out how to parse than it does doing the actual parsing. This adds up. In fact, just the XML processing in AS 5 and 6 took longer than the entire 7 boot time.

Hopefully this provides a better picture as to how we made the efficiency gains, and why some things are very different in 7 than in the past. This, however, is just the beginning. Stay tuned for my next blog which will talk about the overall 7 roadmap.


12. Jul 2011, 17:26 CET, by Jason Greene

You may have heard that AS7 Final has been released! . I plan to say a lot about this, but before I do, I wanted to call attention to the many heroes whose contributions made this monumental release possible.

  • Dan Allen
  • Max Rydahl Andersen
  • Dimitris Andreadis
  • John E. Bailey
  • Marius Bogoevici
  • David Bosschaert
  • Heiko Braun
  • Tomaz Cerar
  • Jean-Frederic Clere
  • Thomas Diesler
  • Andrew Dinn
  • Vladimir Dosoudil
  • Stuart Douglas
  • Steve Ebersole
  • Paul Ferraro
  • Howard Gao
  • Paul Gier
  • Stefan Guilhen
  • Ales Justin
  • Kabir Khan
  • Aslak Knutsen
  • David M. Lloyd
  • Darran Lofthouse
  • Alexey Loubyansky
  • Jim Ma
  • Stefano Maestri
  • Scott Marlow
  • Rémy Maucherat
  • Shelly McGowan
  • Bob McWhirter
  • Marcus Moyses
  • Emanuel Muckenhuber
  • Pete Muir
  • Richard Opalka
  • Jaikiran Pai
  • Jonathan Pearlin
  • Jesper Pedersen
  • James Perkins
  • Flavia Rainone
  • Andrew Lee Rubinger
  • Anil Saldhana
  • Stan Silvert
  • Alessio Soldano
  • Brian Stansberry
  • Scott M Stark
  • Andy Taylor
  • Carlo de Wolf
  • Jeff Zhang

and lastly:

  • The JBoss Community, and all our excellent first class components whose authors are too many to mention.
21. Mar 2011, 17:35 CET, by Jason Greene

I am happy to announce that last week we officially kicked off the beta stream for AS7. This will be a very rapid biweekly release schedule up until we hit CR. So expect to see a lot coming from us very quickly.

The first release of this series is AS 7 Beta1, Ides of March (released on the 15th), and it includes a number of significant changes/improvements over the original alpha.

On the management front, we have moved to fully detyped management model which will allow for Java based management clients to use a single, small library, for controlling any subsystem in AS7. We also now have a new HTTP/JSON interface that allows for applications/tools to be easily written in any language, since most have a number of JSON frameworks already. Finally, we have an initial implementation of our CLI (command line interface). The CLI included in this release focuses on exposing the lower level operation API that is part of our other management interfaces. Future releases will include a more task/command driven layer, which we expect to be the most commonly used.

On the EE front, we have completed the core foundation of our unified component infrastructure. All EE components (Servlets, EJBs, Managed Beans, etc) have common annotation processing, naming, injection, lifecycle, proxy, and interceptor facilities. All of it is dependency based and takes advantage of our lightweight service container. This means that deployments will automatically start in the correct order even with complex relationships. Also if one fails it can succeed later if the facility it depended on becomes available.

In addition we have initial support for a number of the EE web profile (and beyond) technologies including:

  • EJB - Annotation driven SLSBs, SFSBs, and Singletons
  • JPA
  • CDI/Weld
  • JSF
  • Bean Validation
  • JAX-RS / Resteasy
  • JAX-WS

You'll also notice that even with all of these additional services running we still have a very fast boot-up time (1800ms on my system).

You can download the Beta1 release in the usual location

The current getting started wiki is here.

Stay tuned for Beta2...

08. Nov 2010, 23:27 CET, by Jason Greene

As AS6 has been getting closer to CR, we have recently started working on our new next generation application server. Last week, we just released an early alpha of this work, 7.0.0.Alpha1, code named Halloween.

I am putting links first, in case you don't feel like reading my long post:

You can download the release in the usual place here:

There is some basic user instructions here:

Also, Brian, one of our core devs hacked together a quick late-night (yet very nice) demo covering the new powerful management capabilities:

As you can see, the biggest change in AS7 is that we are treating administrators with the same love that we have always shown developers. In particular, we have been doing a lot of thinking about how to make their lives easier when it comes to managing small to very large environments. This is a very important part of a bigger effort you may have heard us reference called "Andiamo", a major focus on improving the usability of JBoss projects and products.

In AS7, configuration is now centralized and presented in a user-friendly manner. So instead of searching for one of our beans.xml files to change some settings for a specific subsystem, you now know exactly where to look. Also the configuration can now describe an entire domain. This means any number of servers, and groupings thereof can be controlled in one place.

For those that don't want to run in a more complex domain topology, we have a simpler more traditional mode you can run JBoss AS in called standalone. The configuration is largely the same, but is slightly simplified, so you still benefit from user-friendly configuration all in one place.

AS7 isn't just about administrators, we are also aiming to make life better for developers as well. One big change we are making is moving to a "pure" modular class-loading environment that will allow us to finally hide our implementation classes from application deployments. In other words, if we decide to use foobar.jar, version 1.1, your application won't see those classes, so it can happily use foobar 2.2.

Another big change on the developer front is that the AS7 service container is fully concurrent, which takes advantage of modern cpus. This among other changes leads to a much improved boot time.

Note that this release just offers a glimpse into the management model and server environment we are working on. EE capabilities will be added as they are developed in subsequent releases.

If you are interested in contributing, check out our Hacking on AS7 page.


03. Sep 2010, 23:22 CET, by Jason Greene

Very rarely do I find a tool that doesn't have some issue I have to workaround (even minor). Even more rarely do I find a tool that continues to impress me beyond what I thought I needed.

Git is such a tool.

Showing 1 to 5 of 13 blog entries