Yesterday i attended a talk on CometD. The talk started with a littl soccer using SunSPOT's to show the capabilites of CometD on the server side.

Apart from that, there's not much to tell about the talk. It was short. It was not really new. But there was 1 thing to mention: the guy who did the talk gave a very clear but rather disgusting demo to show the difference between polling (AJAX) and long polling (Comet) by swallowing lots and lots of M&M's! He wasn't the most skinny person on this planet and so breathing was already audible during his talking. But after the M&M stunt he was almost breathless.

Yes, polling definitely was really resource consuming... for him!

Today's keynotes were not the technical kind of eye candy stuff, but nevertheless really interesting and absolutely necessary.

Ivar Jacobson

The first talk was by Ivar Jacobson, co-founding father of UML (1 of the 3 amigoes). He started with the influence of fashions in IT. About 10 years ago everyone started doing UML. 5 to 7 years ago CMMI was the way to go (especially for managers). And then, 3 years ago, there was eXtreme Programming. And now hardly anyone talks about XP, but Scrum instead. He didn't mention this, but also Scrum is getting out of fashion: now there is Kanban...

Then there is the gap between methodologists, industry and academics. Especially industry and academics don't really like eachother: academics in the eyes of the industry have never delivered something useful and the other way round, the industry doesn't understand what the academics are doing.

As far is methodologies are concerned: there are some many methodologies in the world. Every company has its own methodology. And they all steal from each other. They pick parts from each other, which results in a soup of methodologies... Methodology nowadays is very much a religious discussion: you either believe in and follow the entire methodology (e.g. Scrum, XP, RUP or whatever). But what they basically do, is pick some ideas here and there, add some stuff of yourself and then write a book...

Knowing all these problems, there is a big need for 1 theory of methodologies, away from fashion. We need to refound software engineering based on solid theory, proven principles and best practices. In other words: no more processes, but practices instead. So not RUP, but the practices of RUP. It should deal with both technology and people. And finally it should support extension in face of changing requirements and technology.

This resulted in the creation of SEMAT: Software Engineering Method And Theory. This organization is joined by a number of people of all involved sectors: industry, methodologists, academics.

These are the names of people involved in SEMAT:

Pekka Abrahamsson, Scott Ambler, Jean Bézivin, Dines Bjorner, Barry Boehm, Alistair Coburn, Larry Constantine, Erich Gamma, Tom Gilb, Ellen Gottesdiener, Brian Henderson-Sellers, Watts Humphrey, Martin Griss, Ivar Jacobson, Philippe Kruchten, Stephen Mellor, Bertrand Meyer, James Odell, Meilir Page-Jones, Ken Schwaber, Alec Sharp, Richard Soley.

Note the presence of the following people

• Ken Schwaber, the man behind Scrum
• Alistair Cockburn, the author of the book Writing effective use cases
• Scott Ambler, the man behind Agile UP, Agile modeling and stuff
• Erich Gamma, one of the Gang of Four (design patterns), developer of JUnit, Eclipse and Jazz
• Ivar Jacobson (off course)

All these people know what the problem is, but... they all have a solution to it. Their solution. But this group is not only about finding a solution, a consensus, but also about community, Get everybody's best practices work together, not new practices or "best" practices.

The basic idea of SEMAT is based on a kernel. This kernel is sort of a language to define practices:

• things to to
• things to produce
• patterns to apply
• competences to apply

The kernel should be used to harvest the best practices, see how people use them and for what. Then some practices may be replaced with other practices that may fit better.

Imagine how organizations adopted methodologies like Scrum: many threw away the good practices along with the bad. That's not smart... It is better to gradually introduce practices that work.

On the academic side, people are rewarded for the volume of paper they produce: the more papers they write the more important they are... And students don't really learn what is really useful for the industry. Therefore they should study the kernel and a set of good practices.

Finally, methodologists write book. People buy them, but don't read them... Authors travel around the world to tell what's in the books ;-) Instead of writing books on new methods, they should stand on top of the kernel and its core practices and add their own.

More information: www.semat.org

Robert C. Martin (Uncle Bob)

The keynote of uncle Bob was very animated. His basic idea was that developers still face the same problems as 40 or so years ago, no matter how technology has evolved. Developers and developers still hate eachother: developers still deliver their software too late and management keeps promising unrealistic things.

We should ask ourselves: what is software development? Do we consider ourselves as professionals? Software development should be about craftsmanship. We should be proud what we do and on how we do it. We should deliver good work. But the biggest issue to face is that we should find out what being professional means. And that means in the first place learning to say "No"! Not "I'll try". Professionals, like doctors and lawyers, stand up for their principles. They don't cross that line, they don't compromise. Developers see themselves too much as blue colar workers, being paid per hour.

Another problem is the tendency to promote good developers to management functions. That seems to be the only way to have a carreer. Many companies don't offer a technical specialist carreer path.

As a reaction on this, as a call for action, the manifesto for software craftsmanship was defined. It looks a lot like the agile manifesto and it builds on the fundamentals of the agile manifesto but goes one step further. The aim: have a productive partnership with the management (in order to get rid of the mutual hate).

The manifesto defines a number of ethics and practices, of which a few are mentioned here:

• do no harm!
  • not to your customer
  • not to your company
  • not to your colleagues
• clean code
• to go fast, go well (if you do something good from the first time, you win time)
• test driven development
• 100% test coverage
  OK, really 100% code coverage in unit tests is impossible, but if your unit tests guarantee 80% code coverage, this means that there is 20% of your code of which you're not sure if it is working or not!
• KNOW it works (by code coverage)
• Green bar = shippable
  QA should find NOTHING! If they do, the developers should ask themselves what happened and act upon it!
• QA = specification, not verification.
  This is the definition of "Done", not a huge document that should be tested manually after the development is done.

Uncle Bob's talk was sometimes confronting, but the message was clear: become professional, learn to say "No", don't compromise on your principles and deliver quality!

More information: manifesto.softwarecraftsmanship.org

They reserved the largest room for the Spring talk. They always do... Spring has been a successful topic on Devoxx since its first version. This year Arjen Poutsma cane to give us an update on what was implemented in Spring 3.0; an update because last year he was here to announce what would be in it. Apparently Arjen went through a little makeover since last year :) Check for photo's of last year if you weren't there. The development is done, now they're distributing beta versions. The final version should be available "really soon now".

Spring 3.0 should be concidered as a drop-in replacement for Spring 2.5. That means that it should be fully backwards compatible with Spring 2.5n with some additional features. Spring now makes full usage of the Java 5+ features, like generics, annotations and var-args.

in the past Spring got the complaint to be "XML only'. Now that has changed: you can still use XML (for your legacy applications) and you can use annotations. Now the usage of Spring-specific annotations in POJO's might not be the best choice: this way you make your POJO's directly dependent of Spring annotations. Alternatively, you can use Java config instead: keep your POJO's clean, but isolate the config of the bean instantiations in separate classes.

Expression Language has been in Spring Webflow for a while now. But the new Spring release will exploit the EL capabilities in all the framework components since they moved EL to the core.

The biggest change is in the web, with the introduction of REST and URI templates. You can use templates (in {placeholders}) in the URI's and these can be mapped to variables in your controller code.

REST enforces a clear hierarchy in you data structure. By applying this instead of request parameters you can also fully exploit the http protocol (make full usage of caching features of proxies and servers).

REST supports http-methods GET, PUT, POST and DELETE. Browsers however - for the time being (this may change with HTML 5) - only support GET and POST. Spring can use a hidden http method. This means that your browser does a POST, but that you specify a hidden DELETE. The framework will interprete the hidden method.

ETags are used in combination with caching: the ETag marks the changed status of a resource. This is better that the LastModified value, because ETags can deal with multiple changes per second (lastModified cannot).

Spring 3.0 now supports the Portlet 2.0 spec. Apparently hardly anyone seemed to bother... Maybe our business does? This means that Spring now supports inter portlet communication.

JSR-303, bean validation (as part of the JEE6 spec) also sees an implementation in Spring 3.0. Speaking of JEE6: Spring 3.0 already supports the following JEE6 specs in their current state:

• JSF 2.0
• JPA 2.0
• JSR-303 (bean validation)
• JSR-330 (dependency injection), to which they contributed strongly

Spring is not competing with JEE 6. The add value to the JEE 6 spec where relevant. And as of Spring 3.1 they will fully support JEE 6 (to be expected 2Q 2010).

The following features got pruned:

• pre-Java 5 "annotations" using xDoclets
• Native TopLink support (contributed by Oracle), replaced by JPA

And the following specs are deprecated:

• MVC controller hierarchy
• JUnit 3.8
• Struts 1.x

Release date of Spring 3.0 is not defined yet, but it will definitely by after the finalization of the Java EE 6 spec.

There is only 1 thing really new AND to remember about the keynote of Roberto Chinnici:

December 10th, 2009

That's the day that the spec of Java EE 6 is final. Everything else was already said...

I still have to write my summary of Scott Ambler's talk at Devoxx yesterday on Agile Myth Busters, but I really wanted to have this picture of 1 slide already posted on my blog. This proves with numbers that agile software development really is better than traditional (waterfall) approach.

The picture is not entirely clear, since it is made with a (simple) mobile phone in a room with not very much light.

Look at the bar charts on the left: both iterative and agile projects are more successful (> 70%) than traditional projects (approx. 60%) and hacking.

The bar charts on the right make a distinction between quality, functionality, money and time.

• the green bar represents iterative projects
• the yellow is for agile projects
• the light blue bars are for traditional projects
• the pink/purple bar stand for hacking

Iterative and agile projects score much better on quality and functionality compared to traditional projects. Even hacking delivers more functionality than traditional projects. But the most remarkable is that traditional project score really bad on money and time.

The full summary will also talk about the fact that agile development is not only about small projects by co-located teams...

Thanks, Scott!

My day definitely starts with today's keynote. I really want to see Ivar Jacobson. I've seen him speak last year at Devoxx and I was really impressed. I've read to synopsis of his talk and it really looks interesting.

I'll have to see what the other keynote is about. Worst case I start consuming my battery power again :-)

After the short break it will probably be Spring 3. I saw Arjen Poutsma do a talk about what Spring 3 was going to be (incl. RESTful web services). And this is a great opportunity to compare both talk... Alternatively I could go for Using XML in Java: Spoilt for Choice? But then Arjen should really be boring (which I don't expect). Or... there will be no more free space left in the (biggest) room that I have to look for an alternative.

After the lunch break, by elimination, I choose for Scaling CometD for the Masses. This is an alternative for the Atmosphere talk I attended yesterday. I always have to be careful with choosing a session by elimination, because on Tuesday I chose for SOA in practice by elimination, but I really wasn't happy with this choice...

Afterwards I have an hour free time: nothing really interesting here. So I have some extra time to update my blog.

After the last short break (of the conference) I can choose between Detecting and preventing bugs with pluggable type-checking and Deep dive on the Java EE 6 platform with Glassfish 3. The latter is a talk by Roberto Chinnici (not really fond of him). And this might be a summary of the JEE6 university session I attended on Tuesday... So it will probably the type-checking talk.

And finally I wonder what Project Jigsaw has to offer (the modularity appoach in Standard Java 7).

The fact that "God" came to talk at Devoxx, was a really exciting moment to look forward to. His talk was only announced as "James Gosling". No topic specified. But usually this is enough to get excited... But I guess if he had specified a subject, they wouldn't have reserved the biggest room for his talk and the room wouldn't be as full as it was today.

To be honest, I really thought he had something more interesting to talk about, than an app store... Apparently the introduction of Java FX was the trigger to start an app store like Apple for the iPhone and Google for the Android. And they don't only concentrate on the desktop market. There are 2.5 billion Java capable embedded systems. Those are not only cell phones (and definitely not only smart phones either) but also set top boxes for TV. And the main aim? Play games on it...

Apparently Java's ambitions go back to the early days... Remember applets? And Java Web Start? Some of you may not... Java applets failed where Flash succeeded. And now Java wants revenge with Java FX. To quote Stephan Janssen after the keynote of Adobe: "this is going to be a tough job". And that's really an understatement.

It is not because of James Gosling himself, but if I had known in advance, I would have definitely gone to Ceki Gülcü for his talk on logging (SLF4J and LogBack). Now I have to wait for the talk to be published (free of charge) on Parleys.com. And view it using the Flash player...

The key notes... usually the ideal moment to update my blog... This morning was no exception. The first part was reserved to Stephan Janssen himself, to talk about the conference itself and to present Parleys 3.0. Nice, especially the sub-domains and branding possibilities.

Then the mike was passed to Oracle, to talk about the platform of the future. Not really interesting or fancy stuff. But 1 remarkable thing: Since Sun has become Oracle, OSGi is more prominently present in Java... For the rest, former BEA software (WebLogic) was used for the demo. No fancy JDeveloper demo's like the previous years. Their talk was really an extension of their booth downstairs: boring and nothing to offer... Yes, this was the right time to update my blog, finalizing my post on yesterday's talk about Java EE 6.

Speaking of JEE6... The next speaker was Roberto Chinnici, spec lead of JEE6. As expected, he had nothing new to tell... Again. I already heard all the interesting stuff yesterday.

And finally, there was some space and time left for the toys department: Flash, Flex, etc. Or how can you make your colleague sweat to finalize his demo in time? OK, it looks all nice and it all integrates well (talking about Photoshop, Illustrator and Catalyst). But, doesn't this all smell like vendor lockin?

Anyway, these 2 hours were excellent to consume most of my laptop's battery for the rest of the day... But luckily I had a connection during these 2 hours. The rest of the day I was unable to reach my blog. That's why this update (of this morning) is writting at nearly 9 o'clock in the evening...

I expect a lot more from tomorrow's keynote by Ivar Jacobson. I think it is really amazing that a man almost the age of my dad is still so much involved in the IT business. And he knows what he is talking about, believe me! I saw him last year. That's way I'm so eager to see him again.

After 2 subsequent years of getting the same information on Java EE6, it was about time to get some real information on the evolution of Java EE. And with a different speaker than the past 2 years it was more likely to get a different story. After all, Roberto Chinnici wasn't the most interesting speaker to me (and he's doing a keynote on JEE 6 :-?).

But as the 2 speakers said in the beginning, JEE 6 was very close to being delivered (which means that all the reference implementations of the specs have been developed as well), so we were definitely about to get something new here...

And sure we did! The presentation was a mix of slides and demo's with real code for each topic of the presentation:

• JPA 2.0
• servlet 3.0
• EJB 3.1
• JSF 2.0
• bean validation 1.0
• JAX-RS 1.1

The entire demo is based on Glassfish, which is the platform on which all the reference implementations were built. Glassfish has modularity built in via OSGi, but it is encapsulated into HK2, to make it more extensible. Yes, former Sun was never keen on OSGi, but there was no escaping since so many main players in the Java community use OSGi (with IM in the first place, but also SpringSource).

Configuration in Java EE is more and more optional. All the specs make extensive use of annotations, with better default values. Hope they keep it to a usable level (and avoid annotation hell...).

The Java EE spec as a whole is around since 2001 (starting with J2EE 1.2, built upon the concepts of Java 2).  Back then there were about 10 specs; the newest JEE 6 counts 27 different specs.  Some concepts will be pruned (marked obsolete, might disappear in JEE7): CMP entity beans (replaced by JPA), JAX-RPC (replaced by JAX-WS), JAX-R (XML-registries) and JSR-88 (application deployment).

The major change in the Java EE specification is that a software vendor no longer needs to implement the full specification to be Java EE compliant. The spec allows the definition of profiles for specific (development) domains. The first profile that is defined, is the web profile. This profile is a subset of the full Java EE specification. To be JEE Web Profile compliant, you need to implement the following specs:

• jsf
• servlet
• jsp
• el
• jstl
• ejb lite
• managed beans
• interceptors
• jta
• jpa
• bean validation
• jcdi
• @inject

This means the e.g. Tomcat can be extended to meet the web profile specs to be JEE 6 compliant. Apart from the typical web specifications, the EJB Lite spec should be implemented. This means the following:

• local session beans
• injection
• cmt/bmt
• interceptors
• security

These EJB-related specs are not required in the web profile:

• message driven beans,
• rmi/iiop
• remote interface
• CMP/BMP

Managed beans

New in the Java EE spec is the concept of managed beans. These are container managed POJO's, with support for life cycle management, injection of resources and interceptors. It is a lightweight component model. Sounds familiar. I think I heard something like this about 4 years ago. It was called "Spring" or something... :-) Anyway, the concept of managed beans is re-used for EJB's (= a managed bean with transaction support, security and remotely invocable).

Lifecycle management can be achieved by specifying PostConstruct and PreDestroy annotations to certain methods. There is no more need for a formal constructor; let the beans be created by the container and add lifecycle method to invoke you own logic.

Java Persistence API (JPA)

JPA: evolves separately from EJB spec now. New features:
richer mapping

Querying: JPQL
non-polymorphic querying
joins in subqueries
extra keywords for new functions like ABS, etc.
new locking methods, not only optimistic, also pessimistic, lock, lock and read, read then lock
criteria-API: type safe way for querying data
caching added in persistence
not in the JEE spec, but added cache API because all JEE platform vendors have a second level cache. Annotation @cacheable and api methods to check if data is in the cache.

Servlet API

In the servlet API the remarkable thing is that the web.xml becomes optional/obsolete. Annotations take over the role of configuration: @webservlet.

Pluggability of third-party servlets and web frameworks is improved by providing web-fragment XML-files.

Other new stuff in the servlet API:

• static resources
• config api
• file upload
• servlet security annotation

EJB 3.1

The EJB specification is extended with interceptors, the AOP-way (like - again - in SpringAOP). This means that you can easily plug-in security, logging or performance measuring components.

Local & remote interfaces become optional (only the bean itself with annotations and default all methods are public and locally invocable). Just specify @EJB and you automatically assume a stateless session bean with local invocation and all the (public) methods can be reached.

Asynchronous invocation has been added to EJB's. This means that you don't have to apply JMS for asynchronous calls. JMS is meant for asynchronous message delivery, not method invocation. With asynchronous invocation you can do a fire and forget of a method (if you're not expecting a result of the invocation, off course). Don't start spawning your own threads, because they are not managed by the container!

The timer service has be modified with a cron-likke syntax. The entire principle of the timer got its inspiration from crontab. This can simply be done by adding a @schedule annotation (with the right parameters) to a method of your stateless session bean.

And finally, on the EJB 3.1 spec, there is the singleton bean. By specifying the @singleton annotation to your bean class, you can be absolutely sure that there will be exactly 1 instance of your bean class present in your container. This can e.g. be useful for caching.

Java Server Faces (JSF)

I've never quite understood much of Java Server Faces... And the same goes for the novelties introduced in this new spec... Anyway, I try to recap the key features in the new spec. The new JSF spec can be run indepently of the latest servlet spec. It can runb on Servlet 2.5 but then it requires a web.xml config file (won't work with tghe typical @nnotations).

JSF has always been a rather healthy concept for the component market (re-usable web components) and had good IDE support. But writing your own components was pretty hard. This has been improved in JSF 2.0.

New is also the support for AJAX in JSF. THis can be done in 2 different ways: either via javascript or via a specific AJAX-tag.

Other new stuff in JSF:

• bookmarkable urls
• templating
• project stages (dev/test/prod)

The reference implementation of the new JSF spec is available in Mojarra. It can be used in any runtime (could be tomcat or whatever server).

Bean validation

The bean validation is a new spec in the Java EE platform. It offers a mechanism for validations (hence the name :-)), in a constrain once, validate anywhere way. Validations can be added to properties via annotations and these can be checked on all parts of the application: frontend, mid-tier and backend. A standard number of validation rules are available: not null, length check, range check, ... But you can easily add your own custom validations.

JAX-RS 1.1

The JAX-RS spec is available since mid 2008, but it has has some (minor) changes to fully integrate with Java EE6 (and EJB in particular). As far as REST-support is concerned, there wasn't much new here compared to the talk I attended last year.

This was a very interesting talk. It finally showed something tangible compared to the talks of the JEE6 spec lead the last  years... Besides, at this very moment, he (Roberto Chinnici) is doing a key note on JEE 6. Again: nothing new here (espacially not after I attended this JEE 6 university session).

This morning starts with the obligatory key note. At the moment of writing Stephan Janssen is talking about his Parleys 3.0. Afterwards the "real" keynotes start, with Steven Harris of Oracle about Java, the platform of the future, Roberto Chinnici & Ludovic Champenois about Java EE6 and Glassfish 3.0 (knowing Roberto Chinnici, this might get a bit boooo-ring...). And finally there is an Adobe guy talking about integrating designers into your development. Must be about Photoshop and Flex and stuff...

And then, after the short break, the real interesting stuff starts! Unfortunately the first talk is dilemma... Because at the same time there is a talk about Java SE 7 (which is an must-see at a Java conference) AND Scott Ambler is doing a talk about agile mythbusters. Since I'm sort of a fan of Scott Ambler - he's really an interesting speaker - I will choose for Scott's talk; i can still review the Java SE 7 talk on Parleys, somewhere during 2010 :-). Or ask my colleagues, or read in the internet.

After the lnch break, there is no other talk more interesting than the one of James Gosling. Are there still people out there who don't know James Gosling? These guys must be mainframe developers then, or work in a flower shop or somlething... James is to Java what God is to Mankind. Or, if you're a non-believer, James is to Java what Gütenberg is to printing.

After James' talk, I will attend a talk on Traditional Programming Models, Stones; Knives and Bearskins in the Google Age. This will be very interesting for me, knowing that the majority of developers of the company I work for are mainframe developers... Yes, the stone age still exists (in some places in the world).

After the short break, I'm still in doubt about what talk to attend: either the talk about Comet or the talk about Keeping your eyes open, even if the cload is not. On the one hand, who still needs Comet if there is Kaazing (web sockets implementation in the pre-html5 age)? But on the other hand the cloud talk is a partner talk of IBM. Big Blue has become more green these days, adding a globe to their logo and the 3 letters in 3 different colors (IBM). But partnet slots are merely publicity talks. So I guess it will be Comet...

And the will be my last talk of the day, because  have to leave earlier today (family matters). So probably no free beer & fries for me :-(