Tuesday Jul 02, 2013

JBatch Overview

It seems batch processing is moving more and more into the realm of the Java developer. In recognition of this fact, JBatch (aka Java Batch, JSR 352, Batch Applications for the Java Platform) was added to Java EE 7. In a recent article JBatch specification lead Chris Vignola of IBM provides a high level overview of the API. He discusses the core concepts/motivation, the Job Specification Language, the reader-processor-writer pattern, job operator, job repository, chunking, packaging, partitions, split/flow and the like.

You can also check out the official specification yourself or try things out with the newly released Java EE 7 SDK.

Wednesday Jun 26, 2013

What's New in JMS 2 - Part 1

JMS 2 is one of the most significant parts of Java EE 7. One of the principal goals of the JMS 2 API is improving developer productivity by reducing the amount of code to work with JMS by adopting programming paradigms like higher level abstractions, dependency injection, annotations, runtime exceptions, the builder pattern and intelligent defaults. In a recent OTN article, JMS 2 specification lead Nigel Deakin covers the ease-of-use changes in detail. The article is the first of a two part series on JMS 2. For more visual folks, there is my JMS 2 slide deck:

You can also check out the official specification yourself or try things out with the newly released Java EE 7 SDK.

Tuesday Jun 25, 2013

deny-uncovered-http-methods in Servlet 3.1

Servlet 3.1 is a relatively minor release included in Java EE 7. However, the Java EE foundational API still contains some very important changes. One such set of features are the security enhancements done in Servlet 3.1 such as the new deny-uncovered-http-methods option.

Servlet 3.1 co-spec lead Shing Wai Chan outlines the use case for the feature and shows you how to use it in a recent code example driven post. You can also check out the official specification yourself or try things out with the newly released Java EE 7 SDK.

Monday Jun 24, 2013

Java EE@NY Java SIG

On May 29th, I presented our flagship Java EE 7 talk at the New York Java Special Interest Group. The NY Java SIG is the first Java User Group in existence (since September 1995) and is the largest Java User Group in North America.

The talk went very well - the official RSVP shows a sold out event with 275 attendees. More details, including the slide deck, posted on my personal blog.

Friday Jun 07, 2013

What's New in CDI 1.1?

Introduced in Java EE 6, CDI is clearly a key API to standardize dependency injection in enterprise Java. A lot of the work related to CDI in Java EE now involves treating CDI as an effective mechanism for unifying the Java EE component model and aligning others specs around it to make for a more cohesive platform. Examples of this on-going effort in Java EE 7 includes aligning the JSF component model/scoping to CDI, decoupling declarative transactions from the EJB component model through the JTA 1.2 @Transactional CDI interceptor, modernizing the JMS 2 API utilizing CDI, better support for CDI in Bean Validation 1.1 and many others.

CDI 1.1 itself is a point release that has a relatively long list of smaller but nonetheless important fixes and enhancements. In a recent blog post, CDI 1.1 specification lead Pete Muir does a good job of listing out the changes. The post is especially valuable for the referenced links that you can dig into to see if any of the changes are immediately useful to you if you have adopted CDI already.

Monday Jun 03, 2013

An Overview of the Java API for WebSocket

The Java API for WebSocket (JSR 356) is one of the key parts of Java EE 7. It allows Java developers to write Java HTML5/WebSocket applications with a simple, fluent, high-level API, both on the client and the server-side. With the official Java EE 7 launch looming there's already a flurry of great articles on topics like JSR 356.

In a recent OTN article, Johan Vos provides an overview of the Java API for WebSocket. He covers WebSockets, the JSR, the programming model, API details through code examples and advanced features. The article is a great starting point to learning WebSocket. You could also take a look at my slide deck below.

You are of course encouraged to take a look at the official specification (the JSR recently had it's final release). At fifty some pages, it is pretty digestible.

Friday May 31, 2013

Java EE@JeeConf 2013

JeeConf 2013 was held in historic Kiev on May 24-25. JeeConf is the most significant Java conference in the Ukraine. The conference attracted a bevy of local and international speakers including Venkat Subramaniam, Yakov Fain, Talip Ozturk, Jacek Laskowski, Mohamed Taman and Sander Mak. Topics included Java SE, NoSQL, cloud, HTML5/JavaScript, Arquillian and of course Java EE.

I delivered two very well attended talks - my talk on Java EE 7 (our flagship talk) and a talk on using NoSQL databases in Java EE. More details on the sessions and JeeConf, including the slide decks and code, posted on my personal blog.

Thursday May 30, 2013

Non-Blocking I/O in Servlet 3.1

Servlet 3.1 is a relatively minor release slated for Java EE 7. However, the Java EE foundational API still contains some very important changes, especially for folks building on the Servlet API. One such feature is the newly added support for non-blocking I/O to empower low-latency, high throughput applications, protocols and web frameworks.

Servlet 3.1 co-spec lead Shing Wai Chan shows you how in a recent code example driven post. Incidentally, Servlet 3.1 recently had it's final release. You can now check out the official specification yourself. You can also try the API out with a GlassFish promoted build.

Wednesday May 29, 2013

An Overview of JASPIC 1.1 Changes in Java EE 7

It's easy to focus on just the big ticket changes in Java EE 7 such as WebSocket, JSON-P, JMS 2, JAX-RS 2, Java Batch, Concurrency Utilities and so on but there's actually a lot more going on pretty much across the board. One such set of important but easy to overlook changes are in JASPIC 1.1 (JSR 196).

In a very well written blog post, Arjan Tijms goes over the changes. He talks about the context/motivation for each change along with the technical details and sample code. He also references the very handy change log for JASPIC 1.1. It's a great read if you are interested in Java EE security.

Tuesday May 28, 2013

Nigel Deakin on JMS 2

The 131st episode of the Java Spotlight podcast features an interview with JMS 2 specification lead Nigel Deakin. JMS 2 is one of the key parts of the Java EE 7 platform and a long awaited update to the very popular API. Nigel talks with Roger Brinkley about the motivation for the JSR, the simplified API, the new features, MDB alignment, portable JMS resource definitions in Java EE 7, current status of the JSR as well as what's in the future.

You can listen to the full podcast here. It's really a great starting point for learning about JMS 2. You can certainly give the official specification a read yourself (the API recently had it's final release). At a hundred and fifty some pages, it is not too bad of a read and Nigel does a great job of summarizing the changes towards the beginning of the document in the section titled What is new in JMS 2.0?. You can also try the API out with a GlassFish promoted build.

Thursday May 16, 2013

10 Ways JMS 2 == Less Code

JMS 2 is one of the most significant parts of Java EE 7. One of the principal goals of the JMS 2 API is improving developer productivity by reducing the amount of code to work with JMS by adopting programming paradigms like higher level abstractions, dependency injection, annotations, runtime exceptions, the builder pattern and intelligent defaults. In a brief write-up JMS 2 specification lead Nigel Deakin highlights these changes by demonstrating ten concrete ways the JMS 2 API means less code as compared with JMS 1.1.

JMS 2 recently passed it's final approval ballot. You could check out the proposed final draft yourself. At 150 some pages, it is a pretty digestible specification. You can also try the API out with a GlassFish promoted build.

Friday May 10, 2013

Java EE@JavaOne Russia 2013

JavaOne Russia 2013 was held at the Crocus Expo Center in Moscow on April 23-24. The conference was a resounding success with a great vibe, excellent technical content and numerous world class speakers. Some notable speakers included Werner Keil, Joonas Lehtinen, Heather VanCura, Paul Bakker, Bert Ertman, Talip Ozturk, Anil Gaur, Geertjan Wielenga, Arun Gupta, Jim Weaver, Stephen Chin and David Delabassee. Topics covered included the JCP/JUGs, Java SE 8, Java EE 7, HTML 5/WebSocket, JSF, JMS 2, JAX-RS 2, Java EE Concurrency, JBatch, JSON-P, NetBeans, MySQL, Vaadin, the Oracle Java Cloud, OpenShift, OSGi, JavaFX and Coherence.

 

 

I delivered the Java EE technical keynote, two technical sessions (one on JSM 2 and the other on JAX-RS 2) and three lighting talks (on Java EE Concurrency, JBatch and JSON-P). I also helped deliver two hands-on-labs (on Java EE 7 and the Java Cloud Service). More details on the sessions and JavaOne Russia 2013, including the slide decks and code, posted on my personal blog.

Thursday May 09, 2013

HTTP Upgrades in Servlet 3.1

Servlet 3.1 is a relatively minor release slated for Java EE 7. However, the Java EE foundational API still contains some very important changes, especially for folks building on the Servlet API. The newly added support for HTTP protocol upgrades is a great example. The upgrade facility has been there since HTTP 1.1, but just hasn't been used that widely. It facilitates building richer protocols on top of HTTP. Under the hood, this is exactly the mechanism that HTML 5 WebSockets use (as you know, we now have excellent support for WebSockets in Java EE via JSR 356). You can most certainly use HTTP protocol upgrades in similarly powerful and innovative ways yourself.

Servlet 3.1 co-spec lead Shing Wai Chan shows you how in his recent code example driven post. Incidentally, Servlet 3.1 recently passed it's final approval ballot. You could check out the proposed final draft yourself.

Wednesday May 08, 2013

Santiago Pericas-Geertsen on JAX-RS 2

The 130th episode of the Java Spotlight podcast features an interview with JAX-RS 2 co-spec lead Santiago Pericas-Geertsen. JAX-RS 2 is one of the key parts of the Java EE 7 platform and a vital update to the very popular API. Santiago talks with Roger Brinkley about the motivation for the JSR, some of the API details such as the client API, asynchronous processing, interceptors/filters, Hypermedia support and content negotiation, current status of the JSR as well as what's in the future.

You can listen to the full podcast here. It's really a great starting point for learning about JAX-RS 2. You can certainly give the proposed final draft a read yourself (the API recently passed it's final approval ballot). At ninety some pages, it is not too bad of a read. You can also try the API out with a GlassFish promoted build.

Tuesday Apr 30, 2013

Anthony Lai on Java EE Concurrency Utilities

The 129th episode of the Java Spotlight podcast features an interview with Java EE Concurrency Utilities (JSR 236) spec lead Anthony Lai. As you may be aware, the Java EE Concurrency Utilities has been a long awaited and very important foundational API, especially for third party vendors to more easily integrate with the underlying application server runtime. Anthony talks with Roger Brinkley about the motivation for the JSR, it's long history, some of the API details, current status and the future.

You can listen to the full podcast here. It's really a great starting point for learning about the Java EE Concurrency Utilities. You can certainly give the proposed final draft a read yourself (the API recently passed it's final approval ballot). At fifty some pages, it is a very digestible specification. You can also try the API out with a GlassFish promoted build.