John Gage said at the keynote: "sleeping is optional", but this is not the whole truth. At the JavaONE not only sleeping, but also eating and drinking are optional.
The problem here - too many interesting (and parallel...) sessions at once. And the worst thing are the late BOF-sessions. Because they are even more interesting - the nights are getting shorter and shorter - and you have still a bad feeling that you missed something...

I'm already looking forward for the JavaONE 2008 :-). . ..and I've a SunSpot and some ideas what to do with that...

there should be no problem to attend. In general you have only to wait for the already enrolled attendees.
My session's abstract:

• Loose coupling and interactivity
• Data synchronization
• Transactional approaches
  
• Rich Domain Objects and Databinding (BeansBinding)
  
• Using WebBeans/GlassfishV3 for desktop components
• Hybrid Components (which can be deployed to clients as well as into an container)
• Architectural Patterns and approaches

In the yesterdays JavaOne Session, the look and feel as well as the behavior of a "corporate" application was significanlty changed and improved. Great effects, which not only look great, but also improve the reusability. I never saw similar session about SWT/Jface or any other conference, did I overlooked something? Is it to early, or SWT/JFace applications just don't need to be improved? :-)
Today was another good session, where a great image processing application called "Imagery" was presented. The interesting thing about this: it was an OSGI/Spring based framework called SPAR with Swing frontend. The reason for the uncommon mix: the presenter was not aware of Netbeans RCP and with SWT custom components are supposed to be harder to build.

My session with the short (:-)) title: "Java 6 Platform, Java DB, Swing, JNLP/WebStart, Java Persistence API (JPA)/Enterprise JavaBeans (EJB) 3: The New "Operating System" for Rich Internet Applications", TS-3559, 13.30PM, Hall-E133 seems to be full. Some attendees complained about this. It's amazing, because I will talk at Friday, 13.30 and many of the attendees already fly back home. But if you are interested to chat about the architectures (and see some code :-)), we can meet also afterwards.

Another sample how good Swing Apps look and behave. In the Extreme GUI-Makeover session at JavaONE typical "business" application (a table with master- detail relation and some) was pimped up with relatively little effort. Things like splash screen, validation of widgets with "shaking", reflections, animated sorting of a table, custom components (looks like ajax, flex or flash with mac l&f), fade-in's with blur effects - it was really amazing. The customization was surprisingly simple (mostly inheritance of AbstractOrder, JPanel, etc. with some 2D tricks).

One reason more to attend my session "Java 6, The New Operating System for RIA" TS-3559 at Friday, 13:30 :-).

Some new features of JPA 2.0:

• JPA 2.0 Spec will be decoupled from EJB 3.0
• Better support for embaddable classes
• Better validation support (private @Length(5), @Max(2), @Required - perhaps in align with JSR-303)
• Support of collections of basic types Set<String>
• Support for Mapped Superclasses for Embeddables (so the state of a super Embeddable can be subclassed)
• Support for ordered lists - the order of the items should remain persistent
• The access strategy will be extended so in one entity several access types can be used. For this purpose a new Annotation e.g. @AccessType(PROPERTY|FIELD) might be used.
• @OneToMany mapping is going to be extended, so that the natural way of modelling FKs in the target table will be mandatory (in JPA 1.0 it is optional).
• Expanded support for O/R Mapping - Table per concrete class strategy is going to be mandatory
• In JPA 1.0 all queries are polymorphic, in JPA 2.0 there will be a restriction in place
• JPA 2.0 will support criterias - instead of string concatenation there will be a more fluent way  to define queries
• The HashMap like hints (e.g. logging, caching) are going to be standardized
• Standardization of the Unfetched State (now it is undefined what happens)
• EntityManager could be joined to an existing transaction (e.g. with a method joinTransaction())

The tiny kernel and short startup times in Glassfish v3 could have a huge impact to the architecture of... Rich Clients. The 0.5 (actually 0.486 S :-)) second startup time makes it interesting for embedding it into Rich Clients (e.g. Swing Apps). In that case the Glassfish could be started in process, as an embedded "service" in the client thread. This would in turn allow to use container services, especially DI, transactions and resource management of EntityManagers etc. With this approach the same bytecode could be deployed into the appserver (standalone Glassfish v3), as well as directly to the client (embedded Glassfish v3). The advantage here: you could use direct databinding techniques on the client (no DTOs, VOs etc. are needed any more...), but still make the same business logic available for SOA-like and webapplications.

In my talk TS-3559 (Fiday, 13.30) I will explain the benefits of such architectural approach. ...there is only one big problem: Glassfish v3 do not have support for EJB3 yet... But I already explained  Jerome Dochez the architecture - and he was interested :-).