Wednesday Feb 27, 2013

Transparency and Community Participation in Java EE 7


Ever since the launch of Java EE 7 and its component JSRs, Oracle has been very committed to a high level of transparency for all of the JSRs under the Java EE 7 umbrella. We're so excited that increased transparency has resulted in more useful feedback that has improved the Java EE platform. Let me tell you what we've done, how it's helped, and how you can get involved too.

One of the requirements for JCP 2.8 is:

When voting to approve a JSR's transition to the next stage, EC members are expected to take into consideration the extent to which the Spec Lead is meeting the transparency requirements.

Now that many of these JSRs have gone through the Public Review Ballot and others are in progress, it is useful to review how they have contributed to the transparency process.

First of all, all Java EE 7 Expert Groups are operating using the transparency rules defined JCP 2.8. The transparency rule requires:
  1. Public can read the names on the Expert Group
  2. Expert Group business is regularly reported on a publicly readable alias
  3. Mechanism for allow public to provide feedback
  4. Spec lead respond to the posts on the alias
  5. Schedule of JSR is publicly available, current, and updated regularly
  6. Open source process for the development of RI and/or TCK
  7. Publicly readable and/or writable issue-tracker
  8. Publicly accessible document archive
Happy to report that all the JSRs in Java EE 7 have followed the guidelines mentioned above. Providing a specific example using JSR 342:
  1. JSR 342 has all the Expert Group member names publicly listed
  2. All technical discussions on the Expert Group are reported on jsr342-experts@javaee-spec.java.net alias and archived
  3. Anybody outside the Expert Group can subscribe to the alias at users@javaee-spec.java.net and provide feedback
  4. Spec leads regularly read and respond on the alias
  5. Schedule of JSR is publicly reported at javaee-spec.java.net
  6. GlassFish is the Reference Implementation and is completely built in open source. The promoted builds have been available for several months, the schedule is completely transparent, maven coordinates are published, and NetBeans tooling is available for some time. All this allows developers to play with the bleeding edge Java EE 7 technologies as they are integrated in GlassFish. Public forum allows the users to communicate specifically about the RI.
  7. Publicly readable/writable issue tracker
  8. Publicly accessible document archive
The transparency checklist by each JSR is explained in the table below.

Many of our spec leads have gone beyond this in their outreach to the community with blogs, talks, chats, and more. The Java EE 7 Expert Group recently concluded a public survey seeking community input to define key areas in the platform such as which specifications should be included in the Web Profile, should CDI be enabled by default, expanded use of @Stereotype, and expansions of Interceptors to all Java EE components. Over 1100 respondents voted, make their voices heard, and help decide the direction of the platform.

The table below provides:
  • Public website for each specification in Java EE 7. All of our JSRs that are part of the Java EE 7 Platform are being run in the open, using java.net projects.  These JSRs, and links to their respective projects are listed on the home page of the Java EE 7 Platform JSR and in the table below. Each page has publicly viewable Expert Group mailing lists as Users observer lists. The Users lists receive copies of all expert group emails, as well as providing users the ability to post feedback and engage in discussions with each other and with expert group members. All lists have publicly viewable archives on the java.net project sites.

    Similarly, all projects have publicly accessible download areas, and JIRA issue trackers where bugs and suggestions for new features can be posted, and which also serve as another means of discussion with EG members. The schedules and interim drafts of the specification were posted on the main project page and publicly visible Downloads area.
  • Transparency Checklist columns shows the status of different JSRs meeting the transparency requirements of JCP 2.8.
  • Community Participation represents the increase in community participation above and beyond the core Expert Group for each Specification. As you can see the participation from the community outside the Expert Group is pretty significant and has worked really well.
  • To encourage further community participation, different Java EE 7 Expert Groups defined specific areas to provide feedback using Adopt-a-JSR. We saw tremendous success with the effort with several JUGs joining the effort. The last column lists different JUGs that have adopted a particular JSR. In several cases, JUGs have adopted multiple JSRs.

Specification / JSR Transparency Checklist
Community
Participation
Adopt-a-JSR
A B C D E F G H
Concurrency (JSR 236)

~250%

JPA (JSR 338)
~250%
Chennai JUG
Hyderabad JUG
JAX-RS (JSR 339)
~350%
CE JUG
Indonesia JUG
LJC
Madrid JUG
Morocco JUG
Peru JUG
SouJava
Servlet (JSR 340)
~350%

EL (JSR 341)
~125%

Java EE 7 (JSR 342)
~600%
LJC
JMS (JSR 343)
~500%
FASO JUG
Indonesia JUG
LJC
Peru JUG
JSF 2.2 (JSR 344)
~200%
CE JUG
Chennai JUG
Cologne JUG
Hyderabad JUG
SouJava
EJB (JSR 345)
~300%
SouJava Campinas JUG
CDI (JSR 346)
Only public forum
Chennai JUG
Hyderabad JUG
Indonesia JUG
LJC
Bean Validation (JSR 349) Only public forum
SouJava
Batch (JSR 352)
~750%
Chennai JUG
LJC, SouJava
JSON (JSR 353)
~650%
CE JUG
Congo JUG
LJC
Mbale JUG
Morocco JUG
Peru JUG
SouJava
Toronto JUG
WebSocket (JSR 356)
~400%
BeJUG
LJC
Chennai JUG
Morocco JUG
CEJUG
NY SIG

The map below shows geographical coordinates for different JUGs participating in the Adopt-a-JSR effort for Java EE 7:


View Java EE 7 Adopt-a-JSR Maps in a larger map

Specific contributions from Adopt-a-JSR effort:
  • London Java Community (LJC) organized a WebSocket and JSON Hack Day. The event was sold out within 2 hours and had 17 people on the waiting list. The event started with a presentation on explaining the APIs in Java API for WebSocket (JSR 353) and Java API for JSON Processing (JSR 353). The attendees designed a Market Ticker application. All the presentation material and source code was shared publicly. LJC also created projects (cdiex-palindrom-jsf and cdiex-datastore) to test CDI 1.1 specification.
  • Chennai JUG is building a multi-player game that can be played across the Internet. The application uses Java API for WebSocket 1.0 (JSR 356), Java API for JSON Processing 1.0 (JSR 353), Java Persistence API 2.1 (JSR 338), JavaServer Faces 2.2 (JSR 344) and Batch Applications for Java Platform (JSR 352) and/or Enterprise JavaBeans 3.2 (JSR 345) and so provide a holistic experience of building a Java EE 7 application. The energetic JUG meets regularly using G+ hangouts and in the neighborhood coffee shops to coordinate. And then they go hacking the application on github.  There are 5 developers that are regularly contributing to the application and the JUG plans to incorporate several other technologies as part of an ongoing effort.
  • Morocco JUG will be presenting on Java EE 7, WebSocket, and JSON at Java Developer Conference, Cairo, Egypt.
  • Cologne JUG had a meetup on about JSF 2.2 and another one on CDI 1.1 (video).
  • BeJUG has adopted JSR 356 have planned a hackathon on Mar 6th. They plan to build a cross-browser Tic-Tac-Toe application using JSR 356. One of the JUG members is on its way to become a committer in Tyrus - the Reference Implementation for JSR 356.
  • Ceara JUG has planned a set of presentations on Mar 9 by on JAX-RS 2.0 (JSR 339), Java API for JSON Processing (JSR 353), JavaServer Faces 2.2 (JSR 344), and Java API for WebSocket (JSR 356).
  • San Francisco JUG organized a Java EE 7 and WebSocket session and planning a session on JAX-RS 2.0.
  • SouJava is contributing by adding new features from JSF 2.2 to Scrum Toys.
Several other JUGs are doing an outstanding work and contributing towards making Java EE 7 as the best release ever. All these efforts truly indicate that Java EE 7 is getting grass roots participation from the global community. This truly allows early feedback on the specification and implementation from the end user and developers who will eventually use these APIs. Overall this leads to a higher quality deliverables and will hopefully eventually lead to a faster adoption as well.

Even though many of the JSRs have gone through Public Review Ballot and others are in progress, its never too late to contribute. So how do you contribute ? Just follow this three step process:
  • Join a JUG: If you do not participate in your local Java User Group, then find your local JUG and participate. There are several already active JUGs around the world. If one does not exist in your neighborhood, now is your time to shine as a leader and start one.
  • Participate in Adopt-a-JSR: Encourage JUG members to participate in the global Adopt-a-JSR effort. Several JUGs are already participating and contributing very effectively.
  • Share the joy: Pick any of the Java EE 7 JSRs that are particularly interesting, download GlassFish 4 promoted builds, read javadocs, build a sample application, provide feedback to the Expert Group, and share the joy!
Adopt-a-JSR for Java EE 7: Getting Started provide more details on how your JUGs can contribute effectively.

Java EE 7 JSRs are truly operating in a fully transparent manner and took community participation to a new level. We are always ready for feedback!

Wednesday Dec 19, 2012

Adopt-a-JSR for Java EE 7 - Getting Started


Adopt-a-JSR is an initiative started by JUG leaders to encourage JUG members to get involved in a JSR, in order to increase grass roots participation. This allows JUG members to provide early feedback to specifications before they are finalized in the JCP. The standards in turn become more complete and developer-friendly after getting feedback from a wide variety of audience. adoptajsr.org provide more details about the logistics and benefits for you and your JUG. A similar activity was conducted for OpenJDK as well. Markus Eisele also provide a great introduction to the program (in German).

Java EE 7 (JSR 342) is scheduled to go final in Q2 2013. There are several new JSRs that are getting included in the platform (e.g. WebSocket, JSON, and Batch), a few existing ones are getting an overhaul (e.g. JAX-RS 2 and JMS 2), and several other getting minor updates (e.g. JPA 2.1 and Servlets 3.1). Each Java EE 7 JSR can leverage your expertise and would love your JUG to adopt a JSR.

What does it mean to adopt a JSR ?
  1. Your JUG is going to identify a particular JSR, or multiple JSRs, that is of interest to the JUG members. This is mostly done by polling/discussing on your local JUG members list.
  2. Your JUG will download and review the specification(s) and javadocs for clarity and completeness. The complete set of Java EE 7 specifications, their download links, and EG archives are listed here. glassfish.org/adoptajsr provide specific areas where different specification leads are looking for feedback.
  3. Your JUG can then think of a sample application that can be built using the chosen specification(s). An existing use case (from work or a personal hobby project) may be chosen to be implemented instead. This is where your creativity and uniqueness comes into play.
Most of the implementations are already integrated in GlassFish 4 and others will be integrated soon. You can also explore integration of multiple technologies and provide feedback on the simplicity and ease-of-use of the programming model. Especially look for integration with existing Java EE technologies and see if you find any discrepancies. Report any missing features that may be included in future release of the specification.

The most important part is to provide feedback by filing bugs on the corresponding spec or RI project. Any thing that is not clear either in the spec or implementation should be filed as a bug. This is what will ensure that specification and implementation leads are getting the required feedback and improving the quality of the final deliverable of the JSR.

How do I get started ?

A simple way to get started can be achieved by following S.M.A.R.T. as explained below.

Specific Identify who all will be involved ? What would you like to accomplish ? For example, even though building a sample app will provide real-world validity of the API but because of time constraints you may identify that reviewing the specification and javadocs only can be accomplished. Establish a time frame by which the activities need to be complete.
Measurable Define a success for metrics. For example, this could be the number of bugs filed. Remember, quality of bugs is more important that quantity of bugs. Define your end goal, for example, reviewing 4 chapters of the specification or completing the sample application. Create a dashboard that will highlight your JUG's contribution to this effort.
Attainable Make sure JUG members understand the time commitment required for providing feedback. This can vary based upon the level of involvement (any is good!) and the number of specifications picked. adoptajsr.org defines different categories of involvement. Once again, any level of involvement is good. Just reviewing a chapter, a section, or javadocs for your usecase is helpful.
Relevant Pick JSRs that JUG members are willing and able to work. If the JUG members are not interested then they might loose motivation half-way through. The "able" part is tricky as you can always stretch yourself and learn a new skill ;-)
Time-bound Define a time table of activities with clearly defined tasks. A tentative time table may look like:

Dec 25: Discuss and agree upon the specifications with JUG
Jan 1: Start Adopt-a-JSR for Java EE 7
Jan 15: Initial spec reading complete. Keep thinking through the application that will be implemented.
Jan 22: Early design of the sample application is ready
Jan 29: JUG members agree upon the application
Next 4 weeks: Implement the application

Of course, you'll need to alter this based upon your commitment. Maintaining an activity dashboard will help you monitor and track the progress.

Make sure to keep filing bugs through out the process!

12 JUGs from around the world (SouJava, Campinas JUG, Chennai JUG, London Java Community, BeJUG, Morocco JUG, Peru JUG, Indonesia JUG, Congo JUG, Silicon Valley JUG, Madrid JUG, and Houston JUG) have already adopted one of the Java EE 7 JSRs. I'm already helping some JUGs bootstrap and would love to help your JUG too.

What are you waiting for ?



Saturday Dec 03, 2011

Java EE 7: Key features, Specifications, Projects, Mailing List Archives, ...

An update and summary of the key features of different specifications in the Java EE 7 platform ...

Java EE 7 (JSR 342)
  • The main theme is to easily run applications on private or public clouds
  • The platform will define application metadata descriptor to describe PaaS execution environment such as multi-tenancy, resources sharing, quality-of-service, and dependencies between applications
  • Embrace latest standards like HTML5, WebSocket, JSON and have a standards-based API for each one of them
  • Remove inconsistencies between Managed Beans, EJB, Servlets, JSF, CDI, and JAX-RS
  • Possible inclusion of JAX-RS 2.0 in the Web Profile, revised JMS 2.0 API
  • Technology Refresh for several existing technologies (more on this below) and possible inclusion of Concurrency Utilities for Java EE (JSR 236) and JCache (JSR 107)
  • Status

JPA 2.1 (JSR 338)

  • Support for multi-tenancy
  • Support for stored procedures and vendor function
  • Update and Delete Critieria queries
  • Support for schema generation
  • Persistence Context synchronization
  • CDI injection into listeners
  • Status

JAX-RS 2.0 (JSR 339)

  • Client API - low level using builder pattern and possibly a higher level on top of that
  • Hypermedia - easily create and process links associated with resources
  • Form or Query parameter validation using Bean Validation
  • Closer integration with @Inject, etc
  • Server-side asynchronous request processing
  • Server-side content negotiation using "qs"
  • Status

Servlets 3.1 (JSR 340)

  • Optimize the PaaS model for Web applications
  • Multi tenancy for security, session, resources, etc.
  • Asynchronous IO based on NIO2
  • Simplfiied asynchronous Servlets
  • Utilize Java EE concurrency utilities
  • Enable support for WebSockets
  • Status:

Expression Language 3.0 (JSR 341)

  • Separate ELContext into parsing and evaluation contexts
  • Customizable EL coercion rules
  • Reference static methods and members directly in EL expressions
  • Adding operators like equality, string concatenation, and sizeof etc.
  • Integration with CDI such as generating events before/during/after the expressions are evaluated
  • Status

Java Message Server 2.0 (JSR 343)

  • Ease of development - changes to the JMS programming model to make the application development simpler and easier
  • Remove/Clarify ambiguities in the existing specification
  • Integration with CDI
  • Clarification of the relationship between JMS and other Java EE specs
  • A new mandatory API to allow any JMS provider to be integrated with any Java EE container
  • Multi-tenancy and other cloud-related features from the platform
  • Status

Java Server Faces 2.2 (JSR 344)

  • Ease of Development - making configuration options dynamic, make cc:interface in composite components optional, shorthand URLs for Facelet tag libraries, integration with CDI, OSGi support for JSF artifacts
  • Support implementation of Portlet Bridge 2.0 (JSR 329)
  • Support for HTML5 features like HTML5 Forms, Metadata, Heading and Section content model
  • Flow management, Listener for page navigation events, and new components like FileUpload and BackButton
  • Status

EJB 3.2 (JSR 345)

  • Enhancements to the EJB architecture to enable PaaS, such as multi-tenancy
  • Factorization of container-managed transactions to use outside EJB
  • Further use of annotations
  • Alilgnment and integration with other specifications in the platform
  • Status

CDI 1.1 (JSR 346, more details)

  • Global ordering of interceptors and decorators
  • API for managing built-in contexts
  • Embedded mode to allow startup outside Java EE container
  • Declarative control over which packages/beans are scanned in an archive
  • Injection for static members such as loggers
  • Send Servlet events as CDI event
  • Status

Bean Validation 1.1 (JSR 349)

  • Integration with other Java EE specs
    • JAX-RS: Validate parameters and return values on HTTP calls
    • JAXB: Convert constraints into XML schema descriptor
  • Method level validation
  • Apply constraints on group collection
  • Extend the model to support AND and OR style composition
  • Status
JCache (JSR 107)
  • API and semantics for temporary, in-memory caching of Java objects, including object creation, shared access, spooling, invalidation, and consistency across JVMs
  • Package: javax.cache
  • Status
    • Approved by the JCP
    • Spec lead: Yannis Cosmadopoulos, Cameron Purdy (Oracle) and Gregory Luck (Software AG)
    • Project page: jsr107spec
    • Mailing List Archive: jsr107@googlegroups.com

State Management (JSR 350)
  • API that can be used by applications and Java EE containers to offload the responsibility of statement management into third party providers with different QoS characteristics
  • Java SE-based callers can access the state data by querying the state providers
  • Providers with different QoS can be added and API callers can query to meet their criteria
  • Package: javax.state and javax.state.provider
  • Status
Batch Application for the Java Platform (JSR 352)
  • Programming model for batch applications and a runtime for scheduling and executing jobs
  • Defines Batch Job, Batch Job Step, Batch Application, Batch Executor, and Batch Job Manager for the standard programming model
  • Package: javax.batch
  • Status

Concurrency Utilities for Java EE (JSR 236)

  • Provides a clean, simple, independent API by building on JSR 166, making it appropriate for use within any Java EE contianer.
  • Package: javax.util.concurrent
  • Status
    • Approved by the JCP
    • Spec lead: Anthony Lai, Naresh Revanuru (Oracle)
    • Project page:
    • Mailing List Archive:

Java API for JSON Processing (JSR 353)



The Expert Groups for most of the JSRs have already been formed but you can still participate by joining the publicly visible aliases and reviewing the drafts. All the JSRs following JCP 2.8 are run more transparently and some of the highlights on that front are:

  • Names of the EG members are publicly visible
  • EG business reported on publicly readable alias
  • Schedule is public, current and updated regularly
  • Public can read/write to a wiki to discuss the status so far
  • Discussion board on jcp.org
  • Public read-only issue tracker

And you know all of this will be integrated in GlassFish - the Reference Implementation for Java EE 7!

Check out some early work at glassfish.org/javaone2011.

Tuesday Mar 08, 2011

TOTD #158: Java EE 7 JSRs: JPA 2.1, JAX-RS 2.0, Servlets 3.1, EL 3.0, JMS 2.0, JSF 2.2, CDI 1.1, Bean Validation 1.1

Java EE 6 specifications were approved on Dec 1st 2009 and the corresponding binaries and TCK were released on Dec 10th 2009. Oracle GlassFish Server 3.1 added Clustering and High Availability capabilities to Java EE 6 applications, and many other features, and was released on Feb 28th 2011. Now the wheels are chugging along and several Java EE 7 JSRs have been filed. This Tip Of The Day (TOTD) provides a summary of propopsed features in each of the JSR (make sure to read the proposed JSR for the complete list) ...

Java EE 7 (JSR 342)

  • The main theme is to easily run applications on private or public clouds
  • Application metadata descriptor to describe PaaS execution environment such as multi-tenancy, resources sharing, quality-of-service, and dependencies between applications
  • Embrace latest standards like WebSocket, HTML5, JSON and have a standards-based API for each one of them
  • Remove inconsistencies between Managed Beans, EJB, Servlets, JSF, CDI, and JAX-RS
  • Inclusion of JAX-RS 2.0 in Web Profile
  • Technology Refresh for several existing technologies (more on this below) and possible inclusion of Concurrency Utilities for Java EE (JSR 236) and JCache (JSR 107)
  • Spec leads: Roberto Chinnici, Bill Shannon (Oracle)

JPA 2.1 (JSR 338)

  • Multi-tenancy
  • Support for stored procedures and vendor function
  • Update and Delete Critieria queries, JPQL <-> Critieria mapping
  • Support for schema generation
  • Persistence Context synchronization
  • Dynamic definition of PU
  • Additional event listeners
  • Approved by the JCP EC, watch the progress at jpa-spec@java.net, spec lead: Linda DeMichiel (Oracle)

JAX-RS 2.0 (JSR 339)

  • Client API - low level using builder pattern and a higher level on top of that
  • Hypermedia
  • MVC Pattern - Resource controller and pluggable viewing technology
  • Form or Query parameter validation using Bean Validation
  • Closer integration with @Inject, etc
  • Server-side asynchronous request processing
  • Server-side content negotiation
  • Approved by the JCP EC, watch progress at jax-rs-spec@java.net, spec leads: Roberto Chinnici, Marek Potociar (Oracle)

Servlets 3.1 (JSR 340)

  • Multi tenancy for security, session, resources, etc.
  • Asynchronous IO based on NIO2
  • Simplfiied asynchronous Servlets
  • Utilize Java EE concurrency utilities
  • Enable support for WebSockets
  • Spec leads: Shing Wai Chan, Rajiv Mordani (Oracle)

Expression Language 3.0 (JSR 341)

  • Separate ELContext into parsing and evaluation contexts
  • Customizable EL coercion rules
  • Reference static methods and members directly in EL expressions
  • Adding operators like equality, string concatenation, and sizeof etc.
  • Integration with CDI such as generating events before/during/after the expressions are evaluated
  • Spec lead: Kin-man Chung (Oracle)

Java Message Server 2.0 (JSR 343)

  • Ease of development
  • Remove/Clarify ambiguities in the existing specification
  • Integration with CDI
  • Clarification of the relationship between JMS and other Java EE specs
  • A new mandatory API to allow any JMS provider to be integrated with any Java EE container
  • Spec lead: Nigel Deakin (Oracle)

Java Server Faces 2.2 (JSR 344)

  • Ease of Development - make cc:interface in composite components optional, shorthand URLs for Facelet tag libraries, integration with CDI
  • Support implementation of Portlet Bridge 2.0 (JSR 329)
  • Support for HTML5 features, Flow management, Listener for page navigation events, and new components like FileUpload and BackButton
  • Spec lead: Ed Burns (Oracle)

CDI 1.1 (details - JSR TBD)

  • Global ordering of interceptors and decorators
  • API for managing built-in contexts
  • Embedded mode to startup outside Java EE container
  • Injection for static members such as loggers
  • Send Servlet events as CDI event
  • Spec lead: Pete Muir (RedHat)

Bean Validation 1.1 (details - JSR TBD)

  • Integration with other specs
    • JAX-RS: Validate parameters on HTTP calls
    • JAXB: Convert into XML schema descriptor
    • JPA: DDL Generation
  • Method level validation
  • Apply constrains on group collection
  • Spec lead: Emmanuel Bernard (RedHat)

JPA 2.1 and JAX-RS 2.0 are already approved by the JCP Executive Committee and others are going through a review ballot. And then the EG needs to be formed, specifications and implementations delivered so its a long road ahead. But hey, this group has delivered every time in the past and we'll do it again :-) And this time all the JSRs are run more transparently and some of the highlights on that front are:

  • Names of the EG members are publicly visible
  • EG business reported on publicly readable alias
  • Schedule is public, current and updated regularly
  • Public can read/write to a wiki to discuss the status so far
  • Discussion board on jcp.org
  • Public read-only issue tracker

Here is a latest slide deck I delivered at OTN Developer Day Boston last week giving a good mix of Java EE 6 and providing an insight into the future:

I expect this slide deck to stay current and add more details as they become available, so stay tuned ...

Technorati: totd javaee6 javaee7 glassfish jcp jsr

Tuesday Dec 01, 2009

Java EE 6 specifications approved by JCP - GlassFish v3 & TCK coming soon!

The Java EE 6 and all other related specifications are now approved by the Java Community Process. Here are the votes cast by different JCP Executive Committee members.

And here is the complete list of specifications in the platform:

  • Java EE 6 (JSR 316)
    • Platform
    • Java EE 6 Web Profile
    • Managed Beans 1.0
  • New Specifications
    • Context and Dependency Injection for Java EE (JSR 299)
    • Bean Validation (JSR 303)
    • Java API for RESTful Web Services (JSR 311)
    • Dependency Injection for Java (JSR 330)
  • Major Updates
    • Java Server Faces 2.0 (JSR 314)
    • Java Servlets 3.0 (JSR 315)
    • Java Persistence 2.0 (JSR 317)
    • Enterprise JavaBeans 3.1 & Interceptors 1.1 (JSR 318)
    • Java EE Connector Architecture 1.6 (JSR 322)
  • Minor Updates
    • Java API for XML-based Web Services 2.2 (JSR 224)
    • Java API for XML Binding 2.2 (JSR 222)
    • Web Services Metadata MR3 (JSR 181)
    • JSP 2.2/EL 2.2 (JSR 245)
    • Web Services for Java EE 1.3 (JSR 109)
    • Common Annotations 1.1 (JSR 250)
    • Java Authorization Contract for Containers 1.3 (JSR 115)
    • Java Authentication Service Provider Interface for Containers 1.0 (JSR 196)
  • As is
    • JDBC 3.0 API
    • Java Naming and Directory Interface 1.2
    • Java Message Service 1.1
    • Java Transaction API 1.1
    • Java Transaction Service 1.0
    • JavaMail API Specification 1.4
    • JavaBeans Activation Framework 1.1
    • Java API for XML Processing 1.3
    • Java API for XML-based RPC 1.1
    • SOAP with Attachments API for Java 1.3
    • Java API for XML Registries 1.0
    • Java EE Management Specification 1.1 (JSR 77)
    • Java EE Deployment Specification 1.2 (JSR 88)
    • Java Management Extensions 1.2
    • Java Authentication and Authorization Service 1.0
    • Debugging Support for Other Languages (JSR 45)
    • Standard Tag Library for JSP 1.2 (JSR 52)
    • Streaming API for XML 1.0 (JSR 173)

The complete list is also available in the Appendix section of the platform specification.

Here is the list of specifications in Web Profile 1.0:

  • Java Servlets 3.0
  • JavaServer Pages (JSP) 2.2
  • Expression Language (EL) 2.2
  • Debugging Support for Other Languages 1.0
  • Standard Tag Library for JavaServer Pages 1.2
  • JavaServer Faces (JSF) 2.0
  • Common Annotations for Java Platform 1.1
  • Enterprise JavaBeans (EJB) 3.1 Lite
  • Java Transaction API (JTA) 1.1
  • Java Persistence API (JPA) 2.0
  • Bean Validation 1.0
  • Managed Beans 1.0
  • Interceptors 1.1
  • Context & Dependency Injection for Java EE 1.0
  • Dependency Injection for Java 1.0

Java EE 6 is an extreme makeover of the platform making it much more powerful, takes the ease-of-use momentum created by Java EE 5 to the next step, and also adds flexibility and extensibility to the platform. See other javaee related posts.

The compliant stack in GlassFish v3 & TCK will be released soon!

Technorati: javaee glassfish v3 jcp

Friday Mar 31, 2006

Microsoft joins JCP

On the second anniversary of Microsoft and Sun entering into a broad technology collaboration, Microsoft exceeded expectations on this relationship when they decided to join the Java Community Process (JCP). JCP is an open and participative process to develop and revise the Java technology specifications, reference implementations and test suites. The exact details of their participation are still being worked out but they've already signed the Java Specification Participation Agreement (JSPA) and are now a member of the JCP.

Microsoft and Sun engineers have been working very closely in the recent months to ensure interoperability of enterprise features. This will ensure that Sun's Project Tango, that will be released on java.net and installable on Glassfish, will interoperate with Microsoft's Windows Communication Foundation (aka Indigo) out-of-the-box. After achieving great interoperability results between the two companies in the recent plugfest (Nov '05, Mar '06) meets conducted at Microsoft campus, Microsoft expressed interest in participating in the JSRs relevant to their enterprise feature.

This is an extremely pleasant surprise to the entire developer community since Microsoft's participation in the JCP will ensure that Microsoft can interoperate, not only with Sun, with the entire Java platform.

Interoperability between Microsoft and Sun products, as mentioned above, is a reality but every thing else said above is only wishful thinking since this blog is written to celebrate a special day of the year.

Happy April Fool's Day!

Technorati: Microsoft Sun JCP Interoperability April Fool Indigo

About

profile image
Arun Gupta is a technology enthusiast, a passionate runner, author, and a community guy who works for Oracle Corp.


Java EE 7 Samples

Stay Connected

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today