Tuesday Aug 18, 2015
Wednesday Aug 12, 2015
By reza_rahman on Aug 12, 2015
The Istanbul JUG has been spinning up it's participation in Java EE 8 through Adopt-a-JSR. They have already taken an interest in MVC and JMS 2.1 with many more Java EE 8 JSRs on their radar. The Istanbul JUG is the first Turkish JUG to engage with Adopt-a-JSR and Java EE 8.
Towards this end, the JUG is hosting an event on Adopt-a-JSR to better involve JUG members. The intent of the meeting is to introduce the program and how members can participate in various Java EE 8 JSRs. The meeting will be held on August 13th, 7:30 PM at the Koc University Incubation center. Details of the meeting can be found here (the page is in Turkish and geared towards Istanbul residents).
The Adopt-a-JSR program is one the key things we are trying hard to do differently for Java EE 8 with the goal making this version of the platform one of the most community driven technologies ever developed. Here are just some of the things you could help do via the program right now:
- Raise awareness on Java EE 8 or Adopt-a-JSR by doing a talk or writing a blog entry.
- Read and provide feedback on the MVC specification early draft.
- Try out the MVC specification reference implementation early builds.
- Help contribute to the MVC specification reference implementation.
- Join the MVC specification mailing lists.
- Try out the JSF specification reference implementation early builds.
- Help contribute to the JSF specification reference implementation.
- Join the JSF specification mailing lists and discuss the contents of the upcoming early draft.
- Join the security specification mailing lists.
- Join the CDI specification mailing lists.
- Read the CDI 2 specification early draft and provide your feedback.
- Read and provide feedback on the plan to improving asynchronous JMS message listeners in Java EE.
- Join the JMS specification mailing lists.
- Join the JSON-P specification mailing lists.
- Read the JSON-P 1.1 specification early draft and provide your feedback.
- Join the Servlet 4 specification mailing lists and discuss the contents of the upcoming early draft.
- Join the JSON-B specification mailing lists and discuss the contents of the upcoming early draft.
The full details for Adopt-a-JSR/Java EE 8 is always available here. Remember that if you have any questions on any of this, you are always welcome to drop me a note.
Thursday Apr 02, 2015
By David Delabassee-Oracle on Apr 02, 2015
MVC 1.0 (JSR 371) formally known as the 'Model-View-Controller Specification' has just entered the Early Draft Review period. This is significant because it is the first Java EE 8 specification to enter this phase. Kudos to the JSR 371 Expert Group! JSR 371 is ‘just’ a piece of the Java EE 8 story but this step shows that, slowly but surely, Java EE 8 is starting to take shape.
You are strongly encouraged to review the early draft of the specification, test it using Ozark, the open source JSR 371 Reference Implementation and obviously provide comments and feedback!
The MVC specification is really easy to grasp for anybody familiar with JAX-RS, the samples bundled with Ozark will also help to understand the specification. You can also check Ozark's sources and the presentation I gave a few days ago at JavaLand.
To test the first Ozark milestone build, you need a recent GlassFish build (post 4.1 build, see here for details). Another and simple solution to test JSR 371 and Ozark is to use this script to create a Docker image with GF, Ozark and the JSR 371 samples pre-deployed.
The Early Draft Review period will end of April 30th. For specification related feedback, you can use the JSR 371 users mailing list or the JSR 371 issue tracker. For Ozark related feedback, please use the Ozark users mailing list or the Ozark issue tracker.
So what do you think of JSR 371? Also, should we use this Docker based approach to help you test other upcoming Java EE 8 specifications?
Thursday Mar 12, 2015
By David Delabassee-Oracle on Mar 12, 2015
Do you see any templating solution missing?
If so, it's probably just one contribution away!
Disclamier: it's early days, expect things to evolve!
Wednesday Mar 04, 2015
By David Delabassee-Oracle on Mar 04, 2015
The MVC JSR (JSR 371) is progressing nicely. A key architectural decision was taken a few weeks ago: the MVC JSR will be based on JAX-RS. And since then, the Experts Group has started to publish SNAPSHOT builds :
If you want to lean more about the MVC JSR, make sure to bookmark this page where Manfred Riem (MVC co-spec lead) is tracking all relevant MVC information and resources.
It's still early but you now have everything on hand to start initial testing of this new API. As always, community feedback is a critical factor for the long-term success of this JSR!
Monday Feb 16, 2015
By reza_rahman on Feb 16, 2015
Manfred Riem was a guest on the most recent JSF Central Podcast. For those unaware Manfred is the co-specification lead for both JSF 2.3 and Java EE MVC 1.0. Manfred talked about Mojarra, JSF 2.2, JSF 2.3 as well as MVC 1.0. The podcast is available here and you can read the transcript here.
The podcast is led by Kito Mann - well respected enterprise consultant, author, blogger and JSF community member. Kito has been a long time supporter of JSF with a long track record of contributing as a JCP standards group expert.
The newscast is in fact part of the JSF Central portal and covers topics of interest for the JSF ecosystem. Past contributors to the podcast have included folks like Ed Burns, Cagatay Civici, Neil Griffin, Lincoln Baxter and Shay Shmeltzer. All of the podcasts are archived here.
Besides the podcast, the JSF central portal itself is a very valuable resource for the JSF community you should explore. It does a very nice job listing JSF articles, books, projects, products and other resources.
Wednesday Feb 04, 2015
By reza_rahman on Feb 04, 2015
One of the key Java EE 8 APIs, MVC 1.0 (JSR 371) is solidly moving forward. A key decision for the expert group to consider was whether to base the specification on Servlet or JAX-RS. MVC clearly has many semantic commonalities with both specifications such as HTTP method mapping, mime-type handling, session/request/cookie manipulation and so on. Specifications like JSF and JAX-RS are based on Servlet so it is not unnatural to base MVC on the foundational Java EE specification too. However basing MVC on the lower level Servlet specification would likely mean introducing many APIs that are potential duplicates of what is already available in the higher level JAX-RS API. On the other hand basing MVC on JAX-RS would mean significantly minimizing the possibility of API duplication. It would also mean the programming model between JAX-RS and MVC would be very similar, reducing the learning curve for both newcomers and experienced Java EE developers.
For these reasons it is not too surprising that the expert group has decided to move ahead by basing MVC on JAX-RS. MVC expert group member Ivar Grimstad shares the details including an early view on how the API may wind up looking like in a recent post. Do you have an opinion to share on this?
Thursday Nov 20, 2014
By David Delabassee-Oracle on Nov 20, 2014
Last week at Devoxx, Manfred Riem (MVC 1.0 Co-Specification Lead) did a session on MVC 1.0 (JSR 371) to a packed room. During the session, Geertjan Wielenga (Principal Product Manager in the Oracle Developer Tools) did a cameo appearance to discuss the tooling in the context of MVC. Amongst other things, Geertjan is looking at some of the potential features an IDE could bring to simplify the development of MVC based applications. During the session, Geertjan did a demo based on a prototype he wrote for NetBeans. This demo was also using Manfred’s experimental action based prototype.
So clearly, it's early days! After all the MVC Experts Group has just started and is now discussing important orientations for the specification (e.g Should the Controller be based on the Servlet API or should it be layered on top of JAX-RS?). Nevertheless, it is interesting to follow Geertjan's explorations around tooling in that space. This also demonstrates that adding new features to NetBeans is not necessarily a daunting task!
Monday Oct 20, 2014
By reza_rahman on Oct 20, 2014
Some of you may be aware that MVC 1.0 was launched as JSR 371. Targeted for Java EE 8 the goal of the JSR is to provide a standards based action-oriented web framework for Java EE. 'Why' and 'why now' are two perfectly reasonable questions to explore carefully with regards to this JSR. After all JSF has long been included in Java EE as a standards based MVC web framework. In addition although JSF is a component-oriented web framework there are myriad Java web frameworks that are action-oriented including ones that are very Java EE/CDI friendly such as VRaptor (indeed we had a session on VRaptor at JavaOne 2014).
There's little doubt the web framework space in Java has long been hyper-competitive. There are myriad camps each of which insist their way is the "right" way. Nonetheless in most reliable analysis two schools of thought have consistently come out on top for a number of years - component-oriented frameworks (led largely by JSF) and action-oriented frameworks (lately led by Spring MVC but long dominated by Struts). As a result it has been an open question whether Java EE should support both models much in the same way that .NET has done with ASP.NET and ASP.NET MVC. To put this question to rest we included it in the Java EE 8 survey. Despite all the factors above it turned out that the core Java EE community does in fact see the need to include a standard action-oriented web framework in Java EE, which brings us where we are with MVC 1.0. To answer some of the questions that should naturally arise none other than JSF specification lead Ed Burns put together a very nice analysis piece on OTN that's well worth a read. Red Hat's MVC 1.0 expert group representative Joshua Wilson has done the same as well.
It's obviously not possible to construct an entirely unbiased pro/con analysis matrix for choosing between these two perhaps equally valid major approaches to Java server-side web frameworks. That being said I've tried to encapsulate some of the salient concerns in the graphic below.
To apply a very broad generalization the way I have seen this play out is that heavily form/workflow driven applications where Java developers do a lot of the UI work tends to be written in JSF. There are exceptions (such as eBay - they presented on their JSF usage at JavaOne 2014) but these applications usually reside behind corporate firewalls. More public facing web applications often dominated by web developers tend to be written using action-oriented frameworks.
I hope this helps answer some of the questions you may have had. JSF is here to stay and continues to have a strong community behind it. JSF 2.3 was launched as JSR 372 and is also targeted for Java EE 8. MVC 1.0 will join JSF as a first class peer in Java EE for folks that prefer an action-oriented web framework.
If either of these technologies strongly interest you and you have the time to spare, now is the time to apply to join the respective expert group. Note that you can always participate in a JSR without officially being part of the expert group by simply subscribing to the JSR user alias. Also remember that you can contribute on an even more lightweight format through Adopt-a-JSR.
Please note that any views expressed here are my own only and certainly does not reflect the position of Oracle as a company.
Tuesday Sep 23, 2014
By David Delabassee-Oracle on Sep 23, 2014
Fortunately, we were able to squeeze, the the JavaOne schedule, a dedicated MVC 1.0 BoF. This BoF will be hosted by Manfred Riem who is leading this new specification with Santiago Pericas Geertsen. It will take place on Tuesday Sep. 30 (7:00-7:45 PM) at the Hilton (Continental Ballroom 4), make sure to add it to your schedule!
Tuesday Aug 26, 2014
By David Delabassee-Oracle on Aug 26, 2014
The Model–View–Controller (MVC) pattern has been used for several decades to implement user interfaces. And when it comes to MVC Web frameworks, those can be categorized as action-based or component-based. JavaServer Faces is a component-based MVC framework.
Through the survey, the community has expressed interest in an action-based MVC approach. Santiago Pericas-Geertsen has recently posted a draft proposal for a JSR ('MVC 1.0 JSR') that would define a MVC action-oriented framework for the Java EE platform. This MVC JSR is not intended to replace JSF (component-oriented) but offers, instead, a different approach to building Web applications on the Java EE Platform.
One of the goals of the MVC JSR is to leverage existing platform technologies where it makes sense (e.g. CDI and Bean Validation seems obvious candidates for the Model part).
The initial though was to define this (action-based) MVC framework in the JAX-RS specification but after initial feedback and discussions, the general consensus was that a separate JSR would be more appropriate. Technically, JAX-RS is still one of the option for the Controller part but everything is open and will have to be discussed in the EG. The outcome of those discussions might be that something else is needed for the Controller, or that there's a way to define a Controller independently of the underlying technology and JAX-RS would then be 'plugged' in, we will see... One thing is clear, defining a new template language is not in the scope of the MVC proposal!
We have strong team to lead the MVC JSR : Santiago Pericas-Geertsen (who is also the JAX-RS Specification co-lead) and Manfred Riem (who is also the JSF Specification co-lead). They will, for sure, get support from other community participants (e.g. Red Hat).
In terms of planning, Santiago is looking for supporters before he submits the proposal to the JCP. The JSR itself is aligned with the Java EE 8 planning.
Podcasts & Videos
- JSON-P 1.1/Java EE 8 Webinar at Istanbul JUG
- Asynchronous Support in JAX-RS 2/Java EE 7
- Java API for JSON Binding (JSON-B) 1.0 Early Draft Now Available!
- Java EE @ Chicago Coder Conference 2015
- A new CDI scope in Java EE 8 ?
- A Journey from Tapestry to JSF 2.2 and JavaEE 7
- Submit Now to Win a Duke's Choice Award!
- Adopt-a-JSR/Java EE 8 at Istanbul JUG
- Maven, Java EE and ... NetBeans
- Help Recognize Java Community Process (JCP) Heroes!