The session ‘Applications for the Masses by the Masses: Why Engineers Are an Endangered Species’ by Todd Fast provided a broader look at the development world. It highlighted the trend that the new generations are confident in customizing or extending applications; not in the traditional way but using tools handed by traditional developers. These so-called casual developers create small apps that are widely used. Whether this is a threat depends: those apps have limited timespan (which has impact on the development process: no need for maintainability). The conclusion of the talk being that we are already endangered, but that is inherent to our capacities and will always be, and highschool students will take our current tasks, but we’ll move to more interesting problems (building platforms instead of applications).
Today there is no long lunch break, so I took my lunch, had a quick peek at the Sentilla offering, and went to the ‘Building Rich Applications with Groovy’s SwingBuilder’ session. This looks like a really useful replacement for regular Swing development, making it a competitor to JavaFX in that field. JavaFX seems to have the advantage of being build for UI work (and just that), thereby being more concise. javaFX also allows relative easy integration of Java 2d and soon 3d. The advantage of Groovy being that it can be used for more things, which makes embedding it into a project easier.
‘It’s High Time: A New Date and Time API for the Java Platform’ described JSR310. Is went over the design principles (immutability, factory methods, self documenting and extensible). The examples shown, combined with the current issues make this a desireable API. Their approach with strategie-patterns applied to situations where users might want additional control looks well thought-out.
Next was the session ‘Simply Sweet Applications with Glazed Lists’. Glazed lists are basically java.util.list + observer pattern, but perhaps that is an oversimplification: the library also allows for sorting, filtering and other operations. They allow decorators and make JTable easier to use. This looks like something to be used on a next (Swing or other) project.
My final session for this year was ‘JVM Challenges and Directions in the Multicore Era’ by Cliff Click and Brian Goetz. This was a fantastic session: at a very high speed lots of issues were raised. They started by highlighting that most systems are not ready for large scale concurrency. Garbage collection, JIT and concurrent JVM are well understood and competitive (or beating) native applications. The programming model on the other hand are not there yet: there is still a lot that is not clear. For small multicore systems (2-4 cores) we can benefit from moving background compilation and garbage collection to other cores. Beyond that one needs application level concurrency. This can be task level or data level. With very large numbers of cores (over 64) it’s impossible for large apps because of internal locking and scaling issues. Java’s current concurrency support is too low level. It is also far too easy to make mistakes, and is has too few ways to detect errors. There is also tension between the object oriented model and lock based concurrency. Software Transactional Memory is thought of as a solution, however, it’s not here yet and it’s not guarenteed to work: it’s still a research subject and it might not be as clean as supposed. In real world some things cannot be rolled back (like IO). Other parallel programming pitfalls are in debugging and performance (bandwidth becomes the new problem). Part of the solution is to have a bit more support from the hardware. Some tips: avoid sharing mutable data, use immutable data, encapsulate mutable data and synchronization, write clear code, and document lock behavior.
Unfortunately it is over now. But there will probably be another one next year and in the mean time there are the presentations (and hopefully some audio and perhaps video) of all those sessions I couldn’t attend.
No Pingbacks for this post yet...
Personal blog on my interests.
|<< <||> >>|