RebelLabs Survey Shows Java EE Still Dominant, Solid Java EE 7 Adoption

The RebelLabs Developer Productivity survey is one of the most important ones in the Java ecosystem. It is widely circulated and generally tends to have the most data points. The survey has always asked about Java EE as well as Java SE adoption. The results in the 2016 survey look encouraging for Java EE generally and Java EE 7 specifically, particularly given the seemingly perpetual nay-saying around Java and Java EE in predicable corners of our ever “colorful” industry.

The RebelLabs survey is a bit different from the similar DZone survey in that it asks participants to make mutually exclusive adoption choices. You can either be a Java EE user or a Java SE user. You are only allowed to choose one specific version of Java EE. While this may not be entirely reflective of more complex scenarios in real life, it does make the results a bit more interesting from an analytical perspective. The 2016 results for Java EE adoption are shown in the graphic below. A clear majority of developers – 58% – identified themselves as Java EE users. This is truly remarkable for a mature open standard like Java EE with a number of non-standard product vendors aggressively positioning themselves as competitors to Java EE for many years now. Even more encouragingly developers seem to be solidly behind Java EE 7 – far more so than previous versions including Java EE 6. It is especially good to see the number of J2EE users at a low percentage.

It’s remarkable how similar these results are to other surveys from reliable, neutral sources (the DZone survey results are in the graphic below). There has been another survey from the Vaadin team that also shows Java EE ahead of other alternatives amongst Java developers. I’ll highlight those results as well soon.

While all of this is good news, the Java EE community can ill afford to rest on it’s laurels even for a moment. A number of us in the Java EE Guardian community were very worried what the RebelLabs survey was going to show in 2016. This is because the survey was taken when Oracle’s commitment behind Java EE 8 still remained very uncertain. In fact RebelLabs correctly noted this may be a reason for lower participant support for Java EE compared to other years and the Java EE community has hard work ahead of it.

This is wise advice for the Java EE community and a reason to continue to try our best to advance Java EE. All that being said, it is important to remember that none of these are scientific surveys in any real sense so it is always a good idea to only make high level observations around them. Scientific surveys are truly random, have representative sample sets and clearly identify participants. Most of the surveys we have are unfortunately always self-selection based and at least partially anonymous/online.

On behalf of the Java EE Guardian community it is only correct to thank everyone that indicate their support for Java EE and Java EE 7 in such surveys. Our volunteer driven work is intended to benefit you first and foremost – it is good to see that intent does not get lost in the muddle.

DZone/Java EE Guardians Survey Results: HTTP 2/Servlet 4

As some of you are aware, the Java EE Guardians and DZone jointly conducted a community survey to help determine Java EE 8 features prior to JavaOne 2016. You may also be aware that we shared the results of that survey with Oracle before the details of the renewed Java EE 8 scope was announced. Now is a great time to start analyzing those results a bit more. I’ve already done a high level summary of the results. In this entry I’ll dig specifically into the responses for HTTP/2 and Servlet 4 support in Java EE 8.

Here is how the survey phrased the question:

“The much awaited HTTP/2 standard is now complete, was fifteen years in the making and promises to radically speed up the entire web through a series of fundamental protocol optimizations.

Servlet 4 is the primary vehicle to bring HTTP/2 to server-side Java. Beyond Servlet 4, higher level server-side Java web frameworks like JSF can also take advantage of HTTP/2 to significantly improve performance.

How important is it to bring HTTP/2 support to Java EE?”.

The following graphic shows how the community responded. Clearly developers think HTTP/2 support and Servlet 4 is important for Java EE 8. 65% said it is very important while 25% said it is very important. A mere 1% said it is not important. If you want to learn a bit more about HTTP/2 and Servlet 4, please do feel free to check out my slide deck or screencast on the topic. While it is possible for server implementations to provide some level of HTTP/2 support without Servlet 4, things like server push can only be provided in a manner that developers and framework writers can rely on through Servlet 4. In addition, the Servlet 4 TCK is the only third party verification mechanism that a server actually implements HTTP/2 correctly.

Unsurprisingly, the results for Oracle’s own Java EE 8/9 survey basically mirrors what the DZone/Java EE Guardians survey indicates. The graphic below shows the results of the Oracle survey. Just as in our survey, Servlet 4 is one the APIs that has the strongest support amongst all Java EE 8/9 features.

Here are some representative comments from participants in the order that people filled in the survey: “Servlet 4 and HTTP/2 are probably the most important parts of Java EE 8”, “Very important as there are a lot of improvements in HTTP/2, it is the future”, “I cannot imagine the next iteration of any serious web-based standard or framework not to take (full) advantage of this advance in the underlying technology”, “HTTP/2 is a big step towards faster communications and applications”, “HTTP/2 is the future of the web”, “I develop web applications with JSF, so yes this is very important”, “Clearly more than very important”.

Oracle has recommitted to delivering Servlet 4 by the end of this year or sooner. Although the Oracle specification leads have clearly re-engaged in Servlet 4, progress still lags behind some other Java EE 8 JSRs. That said work on Servlet 4 is visibly spinning up as I am writing this.

Please do stay tuned as I further analyze specific topics in the survey. In addition to my analysis, I would encourage you to look at these survey results yourself and get involved in Java EE 8. You can certainly do so by becoming a part of the Java EE Guardians.

JSF 2.3 Public Review Starts Now!

JSF 2.3 has just posted a public review (this is the last step before the proposed final specification). Like JSF 2.2, this is slated to be mostly a minor update with various incremental features that the community has requested. Indeed the community has driven JSF 2.3 very heavily, directly committing many of the features into the Mojarra code base. Here is a summary of the features slated for JSF 2.3:

  • Alignment with the Java SE 8 Date/Time API
  • Improved CDI support
  • Formally deprecating the JSF specific bean sub-system in favor of CDI
  • WebSocket integration
  • AJAX method invocation
  • Multi-field validation

Besides the above, there are many more smaller grained changes. For details, you should check out the specification document itself (linked below). There is a nice change list at the very start of the document. The community had already been doing a nice job blogging about JSF 2.3 features – particularly folks like Arjan Tijms and Anghel Leonard. Simply Googling JSF 2.3 should go a long way to get a more detailed overview.

You can download and take a look at the draft specification from the JCP site. If you are a JSF user you should do your part by engaging actively. Here are the many ways you can engage (most of this comes directly from the Adopt-a-JSR page I drafted while still at Oracle):

  • You can still join the specification itself as an expert or a contributor. You can do that via the JCP page for the specification.
  • You can have your JUG officially support the standard through Adopt-a-JSR.
  • You can simply join the discussion without any ceremony by subscribing to the JSF specification user alias.
  • You can share ideas and feedback, possibly by entering issues in the public issue tracker.
  • You can read the public review specification now.
  • You can try out the reference implementation now.
  • You can write or speak about JSF 2.3 now.
  • You can encourage others to participate.

The next step is up to you. You can be a real part of Java’s ongoing success yourself instead of simply being a passive consumer. If you have any questions I am happy to try to help – just drop me a note any time.

DZone/Java EE Guardians Survey Results: A Summary

As some of you are aware, the Java EE Guardians and DZone jointly conducted a community survey to help determine Java EE 8 features prior to JavaOne 2016. You may also be aware that we shared the results of that survey with Oracle before the details of the renewed Java EE 8 scope was announced. Now is a great time to start analyzing those results a bit more.

The Motivation and Context
Shortly before JavaOne 2016, after months of silent inactivity, Oracle announced that it was committed to delivering Java EE 8. While this was undoubtedly good news, the problem was that Oracle appeared to also wish to significantly shift the focus of Java EE 8 – basically unilaterally. Oracle’s rationale was that so much time had passed since initial launch that the focus of Java EE 8 needed to be shifted. We thought the best way to ensure that was a wise thing to do is by asking the community directly through an open survey – the very same way the initial scope of Java EE 8 was formulated.

As it turns out now, the core objectives of having the survey was accomplished in more than one way. During the JavaOne time-frame, Oracle announced it’s own open survey not just to determine the scope of Java EE 8, but also the scope of Java EE 9. More recently Oracle announced the results of that survey and finalized the focus of Java EE 8. Although the surveys were clearly different, the results of the Oracle survey was very similar to what the folks that took the DZone/Java EE Guardians survey indicated. Indeed the ultimate good news is that the final focus of Java EE 8 is basically aligned with the results of the Java EE Guardians/DZone survey. Perhaps that isn’t mere coincidence. At JavaOne 2016 the Java EE specification leads promised to take a very close look at the DZone/Java EE Guardians survey results. If they did indeed do that the community should be humbly relieved and grateful.

The Results
The survey did well considering the short time frame that it had been open and the relatively modest resources that we had. In the end we had 800+ input points. While smaller than the Oracle survey this is enough to draw reasonable conclusions on what the community thinks about Java EE 8 scope (for context US professional surveys collect about 1000 random input points for a population size of 300 million+). The quality of the input is quite good including many thoughtful comments. For those that don’t want to read through all the survey results, I’ll provide a short summary:

  • The survey completion rate is 100% which shows how serious the folks that participated are.
  • Almost 70% said they were OK with follow up questions, which shows how engaged the folks that participated are.
  • There was relatively strong support for Servlet 4, Java SE 8 alignment throughout all Java EE APIs, more robust JSON support and a security API overhaul.  
  • There was reasonable support for dynamic configuration and JCache.
  • There was relatively weak support for eliminating EJB in favor of CDI, MVC, NoSQL, more reactive programming and microservices.
  • Most people want Java EE to take a relatively conservative approach to standardization and avoid hype.
  • The majority of people would like to see the Java EE release frequency accelerated.

In the coming weeks I will analyze each of these results in much greater detail. I will also put the results in the context of the Oracle survey results, Oracle’s actions so far as well as other important public data such as the latest ZeroTurnaround developer productivity survey.

What Oracle is Doing
As you may be aware, Oracle promised to deliver Java EE 8 by the end of this year with an altered scope. They have also promised to deliver Java EE 9 by next year. So far things for Java EE 8 look good and it may even be that Java EE 8 will be delivered around the JavaOne 2017 time frame. The following is a summary of what Oracle is doing with Java EE 8 so far:

  • They are moving forward with Servlet 4, JSON-P 1.1, JSON-B 1.0, Java EE Security, JAX-RS 2.1 and JSF 2.3. In addition CDI 2 and Bean Validation 2 is moving forward under Red Hat’s leadership.
  • Oracle is dropping Java EE Management, JMS 2.1 and MVC. However Oracle is transferring full ownership of MVC to the community. The community will move MVC forward on it’s own.
  • Oracle has not stated a clear position on aligning Java EE 8 with Java SE 8. It seems most of this work will be done including changes to JAX-RS, JSF, JPA and JSON-P. I am following up on this topic in the Java EE 8 expert group.
  • Oracle had initially indicated that they would include a new configuration JSR in Java EE 8. It is a bit disappointing that Oracle is now not pursuing this JSR for Java EE 8. However, Oracle has acknowledged that this JSR is important but it is being deferred for now to deliver Java EE 8 on an accelerated schedule.
  • Oracle has not been clear about what it intends to do with JCache. However, it is already possible to use JCache in Java EE applications.

In addition to my more detailed analysis in the next few weeks I would encourage you to look at these survey results yourself and get involved in Java EE 8. You can certainly do so by becoming a part of the Java EE Guardians.

Lastly, this entry would not be complete without mentioning the MicroProfile initiative. The initiative is forging ahead with a 1.1 release. It is targeting many of the features that Oracle is interested in for Java EE 9, including dynamic configuration. The idea is to make collaboration-based microservices centric products from Java EE vendors available essentially before Java EE 8 is released. We can hope that the MicroProfile efforts will converge with Java EE 9 sooner rather than later.

JSON-P 1.1 Public Review Starts Now!

The JSON-P 1.1 (Java API for JSON Processing) specification has just posted a public review (this is the last step before the proposed final specification). For those unaware, JSON-P is a lower level JSON processing API introduced as part of Java EE 7. JSON-P 1.1 is a relatively more minor but important update that will be included in Java EE 8. Java EE 8 will also include a higher level declarative JSON binding API named JSON-B. While JSON binding is clearly important, there are many cases where a simple processing API is more appropriate. JSON-B also depends on JSON-P under the hood.

These two APIs together are extremely important in making JSON a first class citizen of the standard Java platform, just like JAXP (Java API for XML Processing) and JAXB (Java API for XML Binding) did many years ago for XML. With these two APIs in place Java developers can simply think of JSON as yet another Java serialization format. No more third party libraries and no more configuration – things will simply work out of the box when it comes to processing JSON. In my view these APIs are so critical they should indeed be moved to a modular Java SE release, much like JAXB and JAXP are already a part of Java SE.

The changes introduced in JSON-P 1.1 mostly includes staying up-to-date with JSON open standards like JSON Pointer and JSON Patch. There is also some Java SE 8 alignment work included in JSON-P 1.1. A very good resource for an introduction is a slide deck from specification lead Dmitry Kornilov as well as Werner Keil from the community presented at Java2Days 2016 (click here if you can’t see the embedded slide deck).

You can download and take a look at the draft specification from the JCP site. You should do your part demonstrating first hand that JSON-P 1.1 is a critical standard for Java – by engaging actively. Here are the many ways you can engage (most of this comes directly from the Adopt-a-JSR page I drafted while still at Oracle):

  • You can still join the specification itself as an expert or a contributor. You can do that via the JCP page for the specification.
  • You can have your JUG officially support the standard through Adopt-a-JSR.
  • You can simply join the discussion without any ceremony by subscribing to the JSON-P 1.1 specification user alias.
  • You can share ideas and feedback, possibly by entering issues in the public issue tracker.
  • You can read the public review specification now.
  • You can try out the reference implementation now.
  • You can write or speak about JSON-P 1.1 now.
  • You can encourage others to participate.

The next step is up to you. You can be a real part of Java’s ongoing success yourself instead of simply being a passive consumer. If you have any questions I am happy to try to help – just drop me a note any time.

Java EE 7 in Production at Eko Electricity

One of the most important things to do at this stage of the life-cycle of Java EE is highlight successful adoption stories at a regular cadence. The community has been doing just that for a long time including at JavaOne. A number of these stories are curated at Zeef. Sayo Oladeji recently agreed to share a very cool such adoption story on a mission critical system for Eko Electricity – one of Lagos’ largest utilities providers. Sayo had a number of insightful things to say about Java EE worth paying attention to. I have highlighted specific passages that really stand out.

Can you kindly introduce yourself?
I am Sayo Oladeji, a software engineer at Crown Interactive and co-founder at Hextremelabs. I started programming only 10 years ago and over the years I’ve had opportunities to work on Java SE, ME and EE; other JVM languages like Groovy and Kotlin as well as non-Java technologies like C# and Javascript.

I manage a lot of integrations with third-party system like lotto engines, payment gateways, business support systems and so forth.

Can you describe the application that uses Java EE? What does your company do?
Crown Interactive is a major technology provider in the utilities space in Nigeria. We currently provide the end-to-end revenue cycle management (RCM) technology for Eko Electricity Distribution PLC (EKEDP) which serves half of Lagos. To put it in perspective, Lagos has a population of 21 million (2016) and growing at about 85 persons per hour! Besides utilities we also have a lottery system, on-demand media service and a few other applications.

Why did you choose Java EE?
When we started building out the systems we had a lot of Java EE experience on board. Our consultant was also a JBoss partner. Java EE is a proven standard and JBoss EAP provides us with many things out of the box. These include support for web services, clustering, transactions, concurrency, caching, messaging as well as a rich ecosystem of tools; most being open source. It wasn’t a very hard decision to make.

How does the application use Java EE?
We started building the system in a multi-tenant, service-oriented manner from day one. We are now breaking some of the modules down into microservices as needs arise.

  • We use JAX-WS quite heavily due to the kind of integrations we do. JAX-WS + NetBeans makes SOAP integrations a pleasant experience, probably even more pleasant and definitely quicker than REST due to SOAP’s self-documenting nature (WSDL). Handler chains allow us to perform cross-cutting concerns like reading incoming SOAP envelopes and extracting metadata like authentication and tenant information.
  • We use JPA across board for data access.
  • We use JMS for reliable loosely coupled communication between services with ActiveMQ as a message broker and a resource adapter installed for WildFly so that WildFly manages the connections to the broker.
  • We use JAX-RS for the REST APIs which back our AngularJS web front-end.
  • We use EJB for handling our core business logic and also for communication between our microservices. For example, our unified collections gateway (UCG) is a module made up of 8 microservices. One of these publishes an EJB that coordinates the interactions between the remaining. The hierarchical relationship between these modules are also neatly represented in the source code as a Maven multi-module project.
  • Above all, we use CDI heavily. For example, our configurations are centrally managed in a database. We read this into an Infinispan cache (ships with WildFly) on startup and from there CDI producers inject them into beans using qualifiers. This is done in a type-safe manner. The C in CDI is the coolest thing. Bean members are injected based on the context, very important for a multi-tenant system. A JAX-RS filter or JAX-WS handler chain sets up contextual information before execution reaches our beans and the producers being context-aware inject context-specific configuration. We don’t want to bill the wrong partner or load the wrong message template for example.

How was your general experience with Java EE? Would you use it again?
My general experience with Java EE has been very good. Java EE + Maven + NetBeans + IntelliJ IDEA is a really good combination. There are appropriate plugins to configure our server and handle our deployments, generate API docs from REST endpoints, generate JPA entities from database schema and so forth. It’s very quick and easy to get a working project up and running with Java EE 7. Almost everything is POJO and annotation-driven and the generated WAR files are tiny. EE 7 is indeed lightweight.

Prior to using a full Java EE server, I have used Java-based platforms like AppEngine and Tomcat but I’ve generally found full EE servers like WildFly to be far more productive. In fact, with the WildFly Maven plugin + Docker plugin, it is very easy to make a fully functional and cloud-ready environment all from the pom.xml file. We try to have as many of our deployment tasks (such as downloading and installing JDBC drivers, configuring datasources, logging, cache containers, etc) as possible in the project’s pom.xml file so that our CI (BitBucket Pipelines) build file simply runs mvn clean install –P prod. This is also great for the purpose of documentation. Simply looking at the sources, you can confidently tell how the application is going to run.

I have had a great time developing with Java EE 7 and I will make new projects with it.

How can people contact you if they have questions?
I am available on Twitter as @oluwasayo_ and I can also be reached via email at oladejioluwasayo at gmail dot com.

If you have a similarly great Java EE adoption story to share with the community (particularly migration stories from other technologies), please do reach out.

Java SE 8 and 9 at the Philly JUG

The Philly JUG continues to march forward under new leadership and I was honored to deliver the September talk(s!?) myself. As ironic as it may seem, the Philly JUG had not had a dedicated talk on Java SE 8 and it was definitely time to close that gap. Fortunately I have just such as talk handy titled “JavaSE.Next – Java SE 8, Java SE 9 and Beyond”.

The talk covers the big ticket features of Java SE 8 including lambdas, streams, the date/time API and completable futures. I also briefly cover what’s coming in Java SE 9. The slides for the talk is on SlideShare (click here if you can’t see the embedded slides).

We tried something in September the Philly JUG has never tried in it’s long existence – we held meetings in both the Western suburbs as well as center city Philadelphia (our talks have historically been held in the Western suburbs). The suburban meeting was held on September 13 while the center city meeting was held on September 14. Combined, the two meetings had one of the highest RSVPs and attendance numbers the JUG has had for a little bit. The meetings were very well-received and I think the twin meeting locations is something to pursue again when possible in the future. My company CapTech was very gracious to sponsor the food for both meetings.

The Philly JUG’s next meeting on January 17 should be a great follow-up to my talk. Jason Young (also part of the Philly JUG leadership team) is covering Java SE 9 in detail. I highly recommend folks attend the talk and get engaged with Java SE 9 early!

See you at a Philly JUG meeting in the next few months? In the meanwhile, if you have ideas to improve the JUG, feel free to reach out to the leadership team any time – including myself.

Java EE @ App Dev Trends

The App Dev Trends conference was held December 4-9 in Orlando, Florida. Focused on practical enterprise development, it is a brand new part of the popular Live! 360 events. It is chaired by the well-respected veteran technical journalist John K. Waters, editor-in-chief of the Application Development Trends magazine. App Dev Trends helped bring a Java footprint to the otherwise Microsoft technology heavy Live! 360 events, so it was very important for me to help support it.

I was very honored to deliver the opening keynote for the conference. I talked about the critical importance of Java EE to the community, industry and global IT. I discussed the current state of Java EE 8 and Java EE 9, including the Java EE Guardians, the MicroProfile initiative as well as Oracle’s promising announcements at JavaOne 2016. Most importantly I covered what developers can do to help Java and Java EE forward. The heart of the keynote covered the key features Java EE 8 will bring in 2017 such as HTTP/2, a complete security API overhaul, even stronger JSON support, support for HTML 5 Server-Sent Events (SSE), CDI 2, more reactive programming support, more pruning and Java SE 8 alignment. The current slides I used for the talk are here (click here if you can’t see the embedded slide deck):

Later the same morning Kito Mann gave his extremely popular talk on PrimeFaces 6.

After lunch I delivered my talk titled “JCP, Adopt-a-JSR and You”. The talk covers the basics of what the JCP is, how it works and how ordinary developers can participate especially in Java EE 8 JSRs. The talk also covers possible areas of important reform for the JCP. The slide deck for the talk is below (please click here if you can’t see the embedded slide deck).

Concurrent to my talk, Kito delivered a talk on using JAX-RS with AngularJS 2.

The third day of the conference in the morning I delivered my talk titled “Down-to-Earth Microservices with Java EE”. The talk has two aims. The first is to try to do the right thing in explaining what microservices really are, what practical value they offer for most of us and when you should consider them (or not). The second aim is to demonstrate why Java EE makes perfect natural sense for developing sensible real world microservices, so called “monoliths” and everything in between. I also briefly cover WildFly Swarm as well as the MicroProfile initiative. The slide deck for this talk is below (click here if you can’t see the embedded slide deck):

The demo code for the talk is available here. The instructions for the demo are designed to help you set up the demo on your own. I presented this same talk along with Steve Millidge (C2B2, Payara co-founder) at JavaOne. You can view the JavaOne recording of the talk here.

Later in the morning I delivered my brand new talk titled “Java SE 8 for Java EE 7 Developers”. In the talk I cover some of the key features introduced in Java SE 8 including Lamdas, streams, the new Date/Time API as well as Completable Futures and discuss how they can be used effectively with Java EE 7 APIs like Servlets, Java EE Concurrency Utilities, WebSockets, JPA, JSF and JSON-P. I also cover what should be done in Java EE 8 to further improve Java SE 8 support. The slides for the talk are posted on SlideShare (click here if you can’t see the embedded slide deck).

I finished the conference by delivering my talk on HTTP/2 and Servlet 4 titled “HTTP/2 and What it Means for the Java EE Ecosystem”. The talk examines the very important changes in HTTP/2 and how these changes need to be adopted by various Java EE 8 APIs like Servlet 4 and JSF 2.3. The slide deck for the talk is posted on SlideShare (click here if you can’t see the embedded resource).

A screencast of the talk is available here.

All is all, App Dev Trends was worthwhile and I wish the event the best going forward.

Java EE @ Oredev

Oredev was held 7-11 November in Malmo, Sweden. Although modest in size Oredev takes pride in making an effort to bring together the best and brightest speakers around the world. It is one of the few conferences that rely heavily on targeting and inviting specific speakers as opposed to simply utilizing a call-for-papers. This year was no exception with speakers like Adam Bien, Geertjan Wielenga, Ivar Grimstad, Heather VanCura, Chris Judd, Paul Bakker and Holly Cummins. Java EE had a great showing this year.

Oredev was one of the very first international conferences that invited me as a speaker a good few years ago. I have had the pleasure of speaking at the conference a few times since. This year I am honored to be a part of the program committee helping formulate Java content. Having an insider’s look at the conference I am now even more impressed. Throughout the years I have been a part of the program committee for a number of conferences including JavaOne. The genuine care and passion that the Oredev organizers put into the event is truly extraordinary. I am especially happy that a number of speakers I invited were able to be a part of Oredev this year (you know who you are). It was also another good year speaking myself.

I started the conference with my brand new all-day workshop titled “Pragmatic Microservices with Java EE and WildFly Swarm”. I start the workshop with trying to do the right thing in explaining what microservices really are, what practical value they offer for most of us and when you should consider them (or not). The hands-on portion of the workshop starts with running a so-called “monolithic” Java EE application on GlassFish (my plan is to port this code over to WildFly). We then separate a small RESTful service out of the application (a so-called “microservice”). At this stage, the microservice is a simple vanilla Java EE thin war also running on WildFly. We then discuss the pros and cons of Java EE thin wars vs. fat jars as well as WildFly Swarm. The next portion of the lab runs the microservice as a fat jar using WildFly Swarm. We finish the lab by discussing concepts such as Linux containers (e.g. Docker), dynamic discovery, health-check, circuit-breakers/bulkheads and client-side load-balancing. We see these concepts in action using the more advanced features beyond fat jars that WildFly Swarm offers. I also cover the new MicroProfile initiative as well as the Java EE 8/Java EE 9 proposed features geared towards microservices.

The slide deck I use for the workshop is below (click here if you can’t see the embedded slide deck).

A webcast covering the more lecture-oriented parts of the workshop can be found here. The code and instructions for the workshop can be found on GitHub. I’ve deliberately designed the lab materials to be fairly self-guided so you can definitely use the lab materials on your own (or perhaps even run the lab in your own company/JUG) . You are always welcome to reach out to me when needed.

The next morning I delivered my talk on HTTP/2 and Servlet 4 titled “HTTP/2 and What it Means for the Java EE Ecosystem”. The talk examines the very important changes in HTTP/2 and how these changes need to be adopted by various Java EE 8 APIs like Servlet 4 and JSF 2.3. The slide deck for the talk is posted on SlideShare (click here if you can’t see the embedded resource).

A screencast of the talk is available here. In the afternoon there was a nice talk on the upcoming CDI 2 standard delivered by one of the members of the specification expert group.

Early the next day I delivered my brand new talk titled “Java SE 8 for Java EE 7 Developers”. In the talk I cover some of the key features introduced in Java SE 8 including Lamdas, streams, the new Date/Time API as well as Completable Futures and discuss how they can be used effectively with Java EE 7 APIs like Servlets, Java EE Concurrency Utilities, WebSockets, JPA, JSF and JSON-P. I also cover what should be done in Java EE 8 to further improve Java SE 8 support. The slides for the talk are posted on SlideShare (click here if you can’t see the embedded slide deck).

Towards noon, Ivar delivered a talk on the upcoming MVC 1.0 API. Later in the afternoon Heather delivered a very important talk covering the basics of the JCP and how people can participate directly in the creation of open standards like Java EE 8. I have a version of the talk myself here.

After Oredev I had the opportunity to visit one of the very unique sites in Southern Sweden – Ladonia. A self-declared “micronation”, Ladonia was created to protect a truly remarkable piece of art named Nimis. Nimis is best understood by seeing it (or looking at photos like mine below – click on the image or here to view the full album). It is a set of whimsical seaside structures vaguely resembling a giant playhouse made entirely of driftwood. I suggest visiting Ladonia if you get the opportunity. It is a bit hard to get to (perhaps somewhat deliberately) but well worth the effort.

All in all, I really enjoyed my trip to Sweden and Oredev. I hope to go back soon as well as helping out with Oredev.

Java EE @ Java Day Kiev

Java Day Kiev took place 14-15 October. Led by the Ukrainian JUG, it is one of the most significant developer events in Ukraine. The event attracted a bevy of world-class speakers including Burr Sutter, Ivar Grimstad, Sebastian Daschner, Ruslan Sinitskiy and Edson Yanaga. Java EE had an excellent showing at the event including my own talks. The organizers had invited me in previous years but I could not go to Ukraine due to Oracle’s overly conservative travel restrictions. This year was my opportunity for redemption so it was important for me to attend. I suggest others do the same to support Ukrainian developers when they need us most.

The organizers were very kind to arrange a special session on the current state of Java EE with the Ukraine JUG the day before the conference. Ivar and I led the full house session. We talked about Java EE 7 adoption, the importance of Java EE to the ecosystem and the forward plans for Java EE 8 as well as Java EE 9 that Oracle shared at JavaOne 2016. We also talked about the key MicroProfile initiative that aims to bring a collaborative, vendor-neutral approach to microservices in the Java ecosystem. The heart of the talk covers the key features Java EE 8 will bring in 2017 such as HTTP/2, a complete security API overhaul, even stronger JSON support, support for HTML 5 Server-Sent Events (SSE), CDI 2, more reactive programming support, more pruning and Java SE 8 alignment. The current slides for the talk are here (click here if you can’t see the embedded slide deck):

I was also very honored to be part of the opening keynote panel of Java experts. Shortly after the keynote, Ivar did a detailed demo-driven talk on the MicroProfile. After lunch I ran a hands-on lab on JMS 2 titled “Down-and-Dirty with JMS 2”. The goal of the lab is to give attendees some first-hand experience with the primary changes in JMS 2. In the first hour or so I did a brief presentation overviewing JMS 2 and went over the JMS 2 Javadocs. The rest of the time attendees actually wrote JMS 2 code mostly by themselves. The slides I use are available on SlideShare (click here if you can’t see the embedded slide deck).

The lab materials are hosted on GitHub for anyone to use. The lab uses NetBeans, WildFly and Arquillian. I’ve deliberately designed the lab materials to be fairly self-guided so you can definitely use the lab materials on your own (or perhaps even run the lab in your own company/JUG) . You are always welcome to reach out to me when needed. In the lab you’ll basically be putting in code to finish a set of JUnit tests using JMS 2, starting from incomplete code with comments on what to do (don’t worry, a completed solution is also posted :-)).

I started the second day of the conference with my talk on Cargo Tracker/Java EE + DDD. This talk overviews DDD and describes how DDD maps elegantly to Java EE using code examples/demos from the Cargo Tracker Java EE Blue Prints project. Below is the slide deck for the talk (click here if you can’t see the embedded slides):

Concurrent to my talk, Sebastian delivered his brilliant talk titled ‘Java EE – the most lightweight enterprise framework?’. If you really still buy into deliberately spread anti-Java EE propaganda, the linked video will be a serious eye-opener that will make you think twice. After Sebastian’s talk, Ivar did a session covering the details of the Java EE Security 1.0 JSR targeted for Java EE 8.

I finished out the conference with my talk on HTTP/2 and Servlet 4 titled “HTTP/2 and What it Means for the Java EE Ecosystem”. The talk examines the very important changes in HTTP/2 and how these changes need to be adopted by various Java EE 8 APIs like Servlet 4 and JSF 2.3. The slide deck for the talk is posted on SlideShare (click here if you can’t see the embedded resource).

A screencast of the talk is available here. Please do feel free to adopt the material and deliver the talk yourself.

I have been to Ukraine before, but I always missed doing something very unique – visiting Chernobyl. This is because of the fact that you need to have an approved guide and prior official permission for the trip. Thanks to the conference organizers, this time I got to do just that. Do check out the absolutely haunting pictures I took (click on the photo below or here to view the entire album). Anyone that has a chance should visit Chernobyl at least once. It is a first-hand reminder of what our civilization’s tragic self-destructive leanings can lead to. It is also a reminder of how little we actually matter to the planet – a once bustling town is already well in the process of being completely reclaimed by nature in a mere few decades…

What impressed me the most on the Chernobyl trip is something I didn’t even know existed – the secret Duga-3 Soviet ICBM early-detection over-the-horizon radar (the so-called “Russian Woodpecker”). Because there was so little time and I did not have the correct climbing gear, I only went up about five flights of the towering radar. On my next trip to Ukraine I plan to take a day to climb to the very top to witness the stunning views myself – certainly before the amazing structure rusts into the oblivion of time.

All is all, this was a great and overdue trip to Kiev and Ukraine. I hope to visit again soon!