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.

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.

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.

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.

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 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!

The joint community survey on Java EE 8 by the Java EE Guardians and DZone ends September 7. If you haven’t done so already, I strongly suggest participating in the survey now.

The Context
For those unaware, the primary motivation for the survey is to make sure the right features make it into Java EE 8. After months of silent inactivity, Oracle has announced that it is committed to delivering Java EE 8 in time.  While this is undoubtedly good news, a potential problem is that Oracle appears to wish to significantly shift the focus of Java EE 8 compared to the initially promised, highly community-driven scope. The best way to figure out if what Oracle seems to be proposing is the right thing to do is by asking your opinion on Java EE 8 scope through a survey.

You Will be Heard
The survey is deliberately kept brief, high-level and simple. There is also ample opportunity to provide your own comments. You should not underestimate the impact of the survey. Both the Java EE Guardians and DZone will ensure your voice is heard in every avenue possible including the JCP Executive Committee, the umbrella Java EE 8 JSR as well as individual JSRs like Servlet 4.

Some Intermediate Results
So far the survey has done quite well in the short time frame that it has been open. We already have about 600 input points, which is enough to draw some reasonable conclusions on what the community thinks about Java EE 8. However, with a bit of your help, it would be great to cross 1,000 input points for strong consensus based results we can move forward with.

We should all wait just a bit longer for the final results and analysis to be published on DZone in a few weeks. However I think it’s useful to share some initial observations on the input so far:

• The survey completion rate is 100% which shows how serious the folks that are participating are.
• Almost 70% said they were OK with follow up questions, which shows how engaged the folks that are participating are.
• There are a good number of very thoughtful comments from participants.
• The response is fairly predictable for items such as Servlet 4, the Security JSR, JSON, Java SE 8 alignment, JCache, NoSQL, etc.
• People don’t really mind EJB 3+ and don’t prioritize replacing EJB functionality with CDI quickly.
• A significant number of people want Java EE applications to be more configurable.
• A significant number of people want to wait a bit before too much standardization around reactive programming.
• Although opinion is clearly split on microservices, a significant number want to see things like uber-jars standardized.
• A significant number of people want Java EE to take a relatively conservative approach to standardization.
• A very large number of people would like to see the Java EE release frequency accelerated.

Some Final Thoughts
One of the things about Java EE pretty much every Java EE Guardian values is the fact that it is an open standard that has become more and more community driven over the years. This is why we all continue to believe in the JCP. While the JCP isn’t perfect, it is the best mechanism we have today to make sure community input is incorporated as a matter of required due process and transparency into a vendor-neutral technology we can all depend on in the long run. Despite the tough few months the Java EE community has had what we have quietly demonstrated through active engagement is that no one can control the fate of Java EE single-handedly – not even the steward.

I hope that is a powerful motivator for you to do your part and take a mere few minutes to fill out a very important and meaningful survey. It all begins and ends with you.

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. Pavel Pscheidl recently agreed to share a few such adoption stories about Java EE applications he has worked on over a few years. Pavel 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?
My name is Pavel Pscheidl, and of course I’m a Java EE developer. Besides that, I’m a fresh Ph.D. student at the Faculty of Informatics, University of Hradec Králové, Czech Republic. I spend most of my time with Java/Java EE and it’s ecosystem. However, I am also a big fan of Mozilla’s Rust language, using it practically already, mainly on projects related to research, like agent-based simulations.

Can you describe the application or applications that use Java EE? What does your company do?
There are many applications based on Java EE that I’ve worked on. It all started a few years ago by exploring new possibilities. I obtained a contract for building a very special e-commerce application. Back then I discovered the beauty of Java EE 6, mostly CDI and JSF. The project was a major success – everything went well, no technological difficulties or obstacles.

Fast forward to 2016. Currently, I work for a company called Zentity, based in Prague. Zentity specializes in delivering mobile application solutions. Our customers are mainly big banks and telco companies not only in Europe, but all around the world. Building mobile applications for banks is not simple. Most of the interesting work is actually done in back-end systems, providing the necessary security layer, orchestration and overall integration to customer’s current systems. And that is where Java EE shines.

A place for the really fancy stuff with Java EE is in the university. There are multiple projects that can be split into two categories. The major part of our research that relies on Java EE are Internet of Things projects. We build both practical projects and theoretical prototypes. Our IoT-enabled Home Automation System is a perfect example.

We also run Java EE (micro)services for research computations. There is more. For example, one of the projects I’m also partially involved in is building an implementation of SMART adaptive calculator for service costs. Overall, Java EE in it’s seventh version provides us solid background for both commercial and research projects.

Why did you choose Java EE?
The short answer is simple and obvious – it best serves my needs. Java itself is a rich ecosystem and an advantage on it’s own. I can’t image Java to go away one day. Anyway, the word “Enterprise” may have lots of different meanings. Telecommunications, Banking, Healthcare – each domain is different. And Java EE covers them all.

I used to work with different technologies per each project, Ruby here, Python there…Java EE covers it all. It is the strange mix of being complex enough to handle every situation, yet being designed so well everything is easy to understand. Solutions in Java EE are in practice cleanest I’ve ever seen so far. There is no extensive configuration madness, straightforward and reasonable guidelines for everything. This is especially important in larger teams.

If I had to name one part of Java EE that makes me absolutely love it, then I would say CDI and related specifications. CDI is beautifully designed and allows me to build applications with strong focus on the problem domain, not on configuration and wiring everything together. It’s extension capabilities are awesome. That really is impossible to find anywhere else. And I learned to write reusable extensions doing work for developers a lot. It is common for my projects to automatically add new functionality via a combination of extensions and interceptors. These are the main practical reasons I use Java EE and absolutely love it. It just works for me.

It also has a great community and enough literature of great quality. I recommend Beginning Java EE 7 by Antonio Goncalves to everyone, especially students/juniors. This book itself brought us many newcomer Java EE developers.

How does the application or applications use Java EE?
The usage is mostly very complex. Especially at Zentity, I’ve used many of Java EE’s parts in one project. Of course, there is dependency injection in every project. There is JAX-RS, JPA, EJB, asynchronous invocations and schedulers. I also use JSF on many projects. However lately, we’ve replaced the JSF approach with Single-Page-Applications developed with JAX-RS.

The target application server is mostly WildFly and/or Payara. Both are very capable, but for bigger projects with possible demand for support I’m going for Payara. However, WildFly’s ability to server as a load balancer is outstanding, as well as other capabilities like session fail-over. Switching among application servers is easy and picking one is mostly a matter of target environment.

For Internet of Things projects, REST-based microservices are often built with “fat” business logic hidden inside. JAX-RS is great here and the implementation doesn’t matter. And it’s fast too. WildFly’s standalone regime without full profile is often used for microservices – Undertow is great performance-wise. We also use enunciate to automatically generate API documentations whenever possible.

In the future, I’d like to deeply evaluate possibilities of delivering Java EE applications as a “click & run” package. Possibly by dockerizing them, or using WildFly Swarm/Payara Micro. It would solve the only pain I feel when dealing with applications written in Java – JVM gets old and big institutions like banks update slowly. There are many institutions, especially banks operating on deprecated JDK 1.6 with no will to perform an easy update. Delivering applications with both the application server and JDK packed is not an ideal solution in terms of package size.

How was your general experience with Java EE? Would you use it again?My overall experience was very good. I learned a lot from Java EE in terms of design patterns. I will definitely use pure Java EE again in the future. There are many “enterprise” projects waiting for me where Java EE perfectly fits.

Big projects are quite easy with Java EE, yet it is awesome even for small projects with limited functionality and logic. I would like to point out the clean design of Java EE applications. There is no JAR hell, no configuration hell, the projects remain oriented on the target domain. Everything just works and is intuitive. There is also a strong community of enthusiasts who help us all more than they even realize by writing great articles, books, recording educational videos and organizing community events. No one named, no one forgotten. But overall, I find the Java EE ecosystem great.

How can people contact you if they have questions?
The best way to contact me is directly via email – pavel.junior@pscheidl.cz. Other contacts can be found at my personal playground www.pscheidl.cz.

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.

WebSphere V9 “traditional” has recently been fully Java EE 7 certified. In case you are wondering, this is indeed the much maligned “kitchen sink” monolithic version of WebSphere – as opposed to the far more nimble WebSphere Liberty.

Given the very large and loyal customer base IBM has as well as the continued substantial usage rates for WebSphere traditional, this is sure to be a further boost to Java EE 7 adoption. In particular it is important to note that WebSphere V9 also comes with support for Java SE 8.

WebSphere V9 joins the Java EE 7 compatible ranks of JBoss EAP 7, GlassFish 4, WildFly, WebSphere Liberty Profile 8.5.5.6, WebLogic 12.2.1, Hitachi Cosminexus and TmaxSoft JEUS. All of the Java EE certified offerings are always listed on the official Java EE compatibility page. For some perspective few other open standards such as SQL have as many available implementations as Java EE 7 already has (and this is bound to only just keep getting better).

You’ll find the trial link for WebSphere V9 here. IBM senior staffer Tom Alcott has a nice technical write-up on the details of WebSphere V9 certainly including support on various cloud platforms including BlueMix. It should be noted that unlike WebSphere traditional, WebSphere Liberty was one of the earliest available commercial Java EE 7 certified application servers, certainly well ahead of WebLogic and JBoss EAP. You should really check out my WebSphere Liberty Java EE 7 compatibility announcement on The Aquarium, written while I was still at Oracle.

Other than existing WebSphere traditional customers it is honestly difficult to recommend it over WebSphere Liberty. Whatever you may think of the WebSphere brand, you will be doing yourself a disfavor if you do not take WebSphere Liberty seriously. You should definitely not let any open source prejudices unduly hinder your appreciation of the engineering work behind Liberty. It is definitely one of the most modular, lightweight and impressive performing (in every way) modern application platforms available today – Java EE or otherwise. Hopefully that is food for some thought…

A polished and professional logo is important to the identity of any non-trivial effort. Although Java user groups are community efforts, they are no exception. In fact the largest and most successful JUGs in the world almost invariably have a nice logo.

As part of our ongoing revitalization effort, it made total sense to do the same for the Philly JUG. I am proud to say my company CapTech donated design time for the new Philly JUG logo. Below is the high resolution version of the logo.

It seemed like a pretty natural idea to use the iconic Philadelphia Liberty Bell using the style, color and script of the official Java coffee cup logo. My fellow JUG leaders Paul Snyder and Jason Young provided the cool concept to the designers. The logo is now proudly incorporated into our Meetup site as well as our Twitter account.

Besides the primary logo there are the following variants (all are high resolution images):

All of the logos can be browsed and downloaded from here. You should feel free to proudly use the logo. I personally printed out some cool stickers using StickerMule that I will bring as giveaways to the next meeting I go to. For inspiration we have a document with usage suggestions for the logo.

Enjoy!