Floris' Blog

The last day of Devoxx. The booths are gone, the pavilion is closed, just four parallel tracks and three timeslots to go to.

‘The Pomodoro technique’ in the methodology track discussed techniques for gaining flow/focus (whichever you’d like to call it) and optimizing one’s effectiveness. It started with a lengthy introduction on the subject, discussing duration vs events (durations make anxious), the arousal graph (which shows that optimal arousal is somewhere between complexity and redundancy, when something becomes so common it is boring), procrastination. and the attention deficit trait (this is illustrated with a sketch with puppets about a workday that is constantly interrupted). Instead of either having interruptions steer your day or planning everything a year ahead, one should use the pomodoro technique. It works by selecting a subject, working on it for a predefined amount of time (25min) not allowing distractions. During the day you go through a few states: planning in the morning (don’t over- or under-commit). Then do multiple iterations, tracking how you’re doing. In the evening you record how you did, process the data and finally visualize how you can improve your performance. Tools: pencil, timer, todo-today list, activity inventory (big todolist) and recordsheet. During a pomodoro (focus period of 25mins), you break for a few minutes, followed by a minute or so determining what to do next, which might be the same action. After four pomodoro periods you break for a period of 15-20 minutes. If your done with a task within a pomodoro you keep on the activity, optimizing it or leaning from it. The recording phase records the number of pomodoros you did. Interruptions are what hold you back from completing pomodoros (if you stop/break the pomodoro it doesn’t count as a pomodoro), and can be categorised as internal and external. Dealing with the internal interruptions is visualizing and intensifying. A strategy is to add it to the todo-list (marking it as an interruption for tracking). Dealing with external interruptions can be turning off devices and telling people to come back later. Again, this is recorded (with a different mark). If the interruption is so large that you have to stop, you void the pomodoro.

‘Towards a universal VM’ by Brian Goetz and Alex Buckly looked at the evolution of the Java VM from a platform for the Java Language to a platform for all sorts of languages. It is enabled by the JIT: static compilers can generate ‘dumb’ bytecode, while the JIT compiler can work with the information that is only available at runtime. Since the JIT optimizations are bytecode specific, all languages will benefit from those. Now more and more languages are used on the platform, some specific changes are required to the JVM to allow for some ‘tricks’ that Java doesn’t need, but some (dynamic) languages do. Those languages currently simulate the required features, leading to decreased performance. Of the many requested features, more flexible method calls is the most urgent. The result is ‘invokedynamic’, where the VM asks some language logic how to call the method. This allows for multiple problems to be solved at once in an elegant way.

‘Project Lombok: bye bye boilerplate’ was presented nicely. I recently heard about Lombok in several blogs/podcasts, and wanted to check it out. Lombok generates the boilerplate for getters, setters, and constructors on value objects, and it can also be used to generate toString, hashCode and equals methods. Then there’s annotations for cleanup, synchronization and exceptions. The project is available for Javac and Eclipse, volunteers are needed for Netbeans and IntelliJ support. The presentation fell a bit short on clarifying what’s under the hood, but as a tool this could be very useful to reduce the clutter of code.

Another great event has come and gone. The way of picking sessions works well: there were few sessions that were less interesting. I had a great time, and another list of follow-up actions to keep me busy.

Ivar Jacobson presented this morning’s first keynote. He looked at different engineering methodologies and compared the computer industry to fashion. We’re running after hypes with ridiculous ideas (CMM was said to produce great software: look at CMM5 companies in India, it doesn’t automatically; what’s the value of the title scum master if one can become one in two days without a certification exam). He continued to make the case that our industry has quite a bit of problems and that we’ll need some sound foundations to build a new software engineering movement from. The core principle seems to be to create small components with practices and combine them for your situation, instead of trying to implement the latest methodology. By having smaller components it is more clear what new ideas are introduced by the component.
After a small intermission about last year’s RFID experiment (not continued because of privacy concerns: at JavaOne they’re apparently less concerned but that’s the USA ;-)), and thanks to some of the organization, Robert C Martin took the floor for the second keynote ‘filling the professional gap’. Great story teller this man, also known as uncle Bob, is. From seemingly unconnected twists and turns (talking about black holes and his youth), central ideas emerge about professionalism and craftmanship.

‘Using xml with Java: spoilt for choice’ by Michael Kay started with an overview of the different levels of APIs, from SAX/StAX, via DOM variants (warm recommendation for XOM), data binding, to XSLT/XQuery. The latter category is his preferred level of abstraction. On software systems, Java should not be the central component handling the data: Java should be the glue, with XQuery querying the database, and XSLT transforming it for user consumption. There is also a way between the different levels and that seems to be Scala at the moment.

During lunch, I visited the quicky on the combination of Excel and Java. It showed the spreadsheet product/API by Actuate that is free for basic use, and can read/write excel files. It can automatically pull data from files, databases, etc.

The ‘not so dark art of performance tuning’ by Kirk Pepperdine and Dan Hardiker was well attended. In a mix of theory and role playing, different aspects were discussed. The first topic raised was to do load-testing. It took a while for the actual demo to get started, live-demo’s… The talk flowed into what they call ‘hurry up and wait’, where improving one component causes a decrease in performance, which is caused by the load on subsequent components being increased, causing a bigger performance hit. It’s important to measure, instead of guessing, and one way to do this starts with identifying the dominating consumer (application, jvm, hardware or idle process). Followup techniques are: going over threaddumps in jconsole (using the threaddump analyser plugin it is easier to find the information), and time budgeting (taking timestamps at different locations and dumping the time it took). Nice session despite the demo’s having problems.

Skipping the JavaPosse (I’ve seen them quite a few times now, I’ll wait for the podcast this time), passing the carts with beer for the JavaPosse and the crowds going into the room and out of the next room, I went to ‘Google app engine, groovy baby’ by Patrick Chanezon and Guillaume Laforge. Yes, clouds seem to be one of my interest this time. The session gave a good idea of what the app engine can and cannot be used for, although that part was over before I knew it. A large part was on gaelyc, the Groovy library improving on what is provided by the Java version of the Google app engine. I’m not really into Groovy (I just love Javac’s type checking too much) but the app engine is on the list.

‘Detecting and preventing bugs with pluggable type checking’ by Michael Ernst showed how extra type qualifiers and checks can be used to prevent bugs. The examples shown are interesting, and in a comparison with other tools the checker framework comes out as a winner. The checker framework comes with useful checkers, but it was also shown that creating checkers can be easy.

In ‘the modular platform and project Jigsaw’, Mark Reinhold updated us on the state of modularity and jigsaw in particular. Most of the talk is old news, but several recent developments are encapsulated modules (do not leak to users of a module), optional modules, virtual modules (support for different device types), native packaging (apparently the tooling will support Debian packages). A lot of work has been done on simplifying the proposed JRE modules, and the number of modules and links between them has significantly been reduced. As of this presentation, jigsaw has been made available for Ubuntu (although it’s still a rough development version)!

Today ended with a special showing of 2012 for the Devoxx attendees. Well, see for yourselves, but I think it’s quite a decent movie…

Devoxx has been described as the JavaOne of Europe. It is actually quite a bit smaller, but in the great metropolis venue in Antwerp. This year continues the tradition of a breakfast with lots of sweet food on the tables.

The keynote was started by Stephan Janssen, going over some statistics (yes everything bad is still blamed on the economy) and the next version of Parleys, which, not surprisingly, will feature a subscription model.
Steven G Harris of Oracle got the floor (wearing a glassfish polo), and emphasized he could not talk about the merger, and made the mandatory yokes. A general overview of Java technology (which was so general that it could have been Sun on stage) is followed by a technical demonstration of Weblogic DM, showing their work on profiles, modularity (distributed OSGi) and grid technology. Another demo, later on, showed the deployment of the application on a Java appliance (running the JVM directly on the hypervisor). They then highlighted the evolution of the JCP and their involvement before going over some technology and platform challenges. Two challenges jumped out at me ‘identify enabling capabilities to make Java more competitive’ and ‘developers/deployers want just enough, not more’. The first probably is more testament to the Oracle way of communicating, but perhaps also a glimpse of the road Oracle wants to steer Java, the latter is what I see happening around me but hadn’t really expected to hear at a conference where the focus is on new technologies. They ended with a statement about ‘making Java the platform of the future’.
The Sun keynote (from Gosling’s blog I already knew he’d not be on stage for the keynote) showed the progress made on the EE platform (yes it’s almost there), showing JAX-RS, bean validation, the web profile, modularity, dependency injection, EJB 3.1, JSF 2.0. In contrast to Oracle’s keynote, this session was much more technical (read: enjoyable), even though it only touched the highlights. The demo showed some of the capabilities that should increase speed of development of JEE apps.
Chet Haase demonstrated some Adobe eye candy during their keynote. The next Flash version (10.1) should be faster and available on many devices. Air has been enhanced with more native platform interaction support. The Catalist demo was rushed (but I recently got the gist during a similar demo at JFall).

The Clojure session by Howard Ship started from the problems with concurrency, and introduced Clojure with ‘OMG it’s Lisp!’. Well indeed, I’m having flash-backs to my days in university. The presentation flowed nicely, going over key concepts, syntax and what makes Clojure different from Lisp or usable in an Java environment. Nice one to play with!

During lunch there is some time for quickies, if you want to escape the crowds and heat of the pavilion. The Swing and OSGi quicky shows a pattern to solve the create/connect/initialize ordering problems that occur due to interactions between Swing and your OSGi container.

Architecting robust applications for amazon EC2 started with the question ‘how long would it take you to get hold of a few servers if you’d wanted to try out something next monday?’. Well I think that unless you have a few machines standing idle, the answer for most of us would be in the order of a few weeks. The presentation was plagued with technical difficulties (audio and video down). The session did a good job of showing what’s involved in running services in the cloud.

Traditional programming models: stone knives and bearskins in the Google age by Cameron Purdy is packed: people are sitting in corridors. Different theories and quotes are interwoven to create an entertaining talk about what’s one of our biggest challenges: building scalable software. How to deal with load? Do load balancing, partitioning, relax data consistency rules, parallelize, queue (if bulk processing is more efficient). Five patterns are given: routing, partitioning, availability by backup/replication, messaging between partitions, and coordination for transactions over multiple partitions. Ultimately, we’ll need to decompose transactions into idempotent steps (so they can be repeated for failover) and execute those efficiently by taking the action to the data. By modeling the steps as events (and the other recommendations) very scalable systems can be built.

‘Keeping your options open, even if the cloud is not’ was a session hosted by IBM. After a long introduction of cloud computing and many questions directed at the audience, the focus shifted to standards, portability and interoperability. It also discussed levels of APIs: developing for the wireprotocol, using language libraries, service APIs and vendor
independent service type APIs. Efforts are underway to create such an API for a subset of cloud services (primarily data storage/retrieval).

The last real session of the day is ‘animation rules!’ by pixel wizards Chet Haase and Romain Guy. The talked about the original rules (as created at disney) for creating cartoons and their applicability to modern animations in user interfaces.
- Squash & stretch is about deforming objects as a reaction to gravity, collision or other forces. In GUIs it makes objects more fun and interactive.
- Anticipation helps viewers to understand what will happen by playing a short action just before the main one. It also helps to guide the attention. In the GUI it is also helpful to understand what will happen.
- Staging is about clearly communicating what is happening. In GUIs it is used to emphasize important elements and avoid noise.
- Straight ahead vs pose to pose is about the effort put into the animation. For computers is mostly pose to pose, but it can be more extensive using more keyframes.
- Follow through, overlapping action is about making motions more realistic by not animating things as rigid bodies. In UIs it makes things more playful.
- Slow in and out is about using non linear movements. It makes movements appear more natural.
- Arcs is similar to the previous, except that this is about the motion: straight from a to b is dull and unrealistic.
- Secondary action is an additional action to emphasize or complement the main action. In user interfaces an example of this is frosting the UI when showing a dialog.
- Timing is about realism. Is gives a feeling of the physical characteristics of the object. In user interfaces it is mostly about the correct durations of animations.
- Exaggeration is about making actions more lively, obvious and entertaining. In GUIs you’ll need to be careful and not overdo it.
- Solid drawing: learn to draw first, before animating it. Also true for user interfaces.
- Appeal is about making the object not only well drawn but also appealing to look at. For user-interfaces it is about friendliness.
Their proposed rules are to consider times, designed, smooth, transitioning, realistic anticipatory and simple.

After a few beers and fries, we went to the JDK7 BOF. Quite a change: it seems the JDK has been delayed and closures might be included after all. It is all sketchy, and the original proposals are taken as inspiration. Several questions on bytecode issues. For Jigsaw one can gather files from the repository, but in a few days there might be binaries. Quote by Brian Goetz: ‘The STM model feels like a crutch’. Lots of concerns and features were requested, although people already know there is little change those will ever be included in Java.

All in all an exhausting day with good sessions: more to come tomorrow!