Floris' Blog

It’s time for James’ toy show! He first gave some Duke’s choice awards to Terracotta, Atlassian and blueJ. The Jagex team gave a demo of the editors used for RuneScape character creation and landscape creation: the ease with which these seem to work is amazing. Simon Ritter and Angela Caicedo did some demo’s (the card projection and virtual painting on frosted glass). Tor Norbye showed what can be done with the new JavaFX editor. Debugging a simcard on a mobile phone plus communication with a remote SunSpot failed to impress. The winners of the FIRST robotics competition got on stage and had some fun gathering objects and throwing them at James. They received an award because FIRST is switching to Java as the platform to develop on, and because it just looks cool. With someone from ND SatCom, James showed a picture from his youth, programming on a PDP-8 for satellite communications before showing how Java is now used to control the basestations and perform spectrum analysis. Visuvi was asked on stage to demo their image search engine: mindblowing. Grameen Foundation facilitates micro-finance using their ‘mifos’ platform and showed that platform to us. Check1two demonstrated their jukebox app, with their CEO playing(?) the ’starving musician’ role. Two students from Bulgaria demonstrated their winning entry in a Ricoh contest with an application that scans and rates multiple choice answer sheets. Volkswagen electronics showed their work to get an Audi TTS rallycar to drive autonomous over a track, based on JavaRTS (project Bixby). The show ended with a project announced on JavaOne last year. Last year Neal Young mentioned going for the automotive X-prize: This year the LincVolt is presented: an old Lincoln continental, converted to run on batteries (which can be charged using a generator) and Java.

‘Under the Hood: Inside a High-Performance JVM Machine’ provided looks into the JVM (seemingly that of IBM, but many concepts apply to all modern JVMs). Performance has been improved over the last years by better processors (and understanding the memory hierarchy), better language understanding (idiom recognition) and processing budget (taking advantage of new instructions and more cores). The talk went over the architecture (and the way that makes Java run on multiple platforms) and into the optimizations in the JIT. From a tree and some other data, multiple optimizations (a library of ~150 optimizations) can be iteratively applied. The choice for applying a certain optimization is based on code quality compile-time trade-offs that derive from how ‘hot’ code is or whether your debugging or profiling. Examples using assembler code show the radical different optimizations made at different compilation levels. The garbage collector is also an important part, where there is no one perfect solution: performance depends on how willing you are to accept pauses, but also on hardware. Thread local heap performance is improved by allocating more heap space than required (so instead of allocating a few bytes, more is allocated, which can be used for next requests for allocation space). As this may lead to fragmentation, some bookkeeping is performed and above certain thresholds, compaction kicks in. It also addresses the compressed references: larger object references used on 64bit systems decrease performance. By utilizing the fact the objects are 8-byte aligned and realizing that most heaps address at most 32GB, the pointers can be compressed to the same size as on 32bit systems, and it opens some extra benefits on certain platforms as well. Threading and monitoring optimizations attempt to reduce the penalty of Java using monitors everywhere. Optimizations include ‘tasuki locks’. Since monitoring and stability are important, the last GC data etc is dumped on a VM or application crash. Users of the IBM VM should check out ‘health check’.

Another session on performance followed suit, titled ‘Robust and Scalable Concurrent Programming: Lessons from the Trenches’, by people from eBay. It started with the regular blah about concurrency being hard, most developers not fully understanding it, etc. Making scalable software is even harder, as it requires one to understand what happens when the system is under concurrent load and the mechanisms that allow one to make trade-offs. The session went over some some patterns. The first being lazy initialization, showing you should be careful to get it right and that some ways of getting it right do not scale. The best solution is eager initialization, but in some situations you could use the holder pattern or the corrected double-checked locking. Second is the map & compound operation, of which different version are shown to be broken in one way or another. Another pitfall is the use of non-threadsafe classes like SimpleDateFormat (solution: just allocate a new instance or make it thread local). Others are to be aware of hidden costs such as in class.forName() as it takes many locks and walks the classpath: calling it multiple times is not an issue if the class is found, but it becomes a hotspot if the class cannot be found. The conclusion is that thread safety should be considered non-negotiable, after that improve scalability, and usually that involves only fixing a few contended locks. Be both proactive as well as reactive.

Another session on JVM details was ‘Inside Out: A Modern Virtual Machine Revealed’, again a session with Goetz and other smart minds. It went over the advantages of having a virtual machine: the obvious being portability and security. Not so obvious is performance: the VM can choose to apply optimizations not available on all chips. Having a virtual instruction set allows higher level abstractions, and constraining some things leads to more possibilities for optimization. The VM also does dynamic compilation, so the system can profile codepaths and aggressively optimize them. Virtual Method calls served as an example of the optimizations that can be made by the optimizer. Speculative optimization is another thing VMs can do, as well as scalar replacement (sometimes objects are not necessary and can be replaced by some fields in registers). An enabling technique to this is escape analysis. Lock coarsening, lock elision, biased locking (based on information collected at runtime by the profiler) are applied to mitigate the costs of locking. For garbage collection there are techniques such as object relocation, and the fastest path for object allocation can be as low as 10 instructions. These things help cache locality, and can easily outperform malloc and free. Some obscure optimizations are large pages (handling the issue of scarce TLBs) and NUMA awareness, which allows threads to be scheduled at their home-nodes when possible, giving a modest to huge performence improvement. Conclusion is that by giving up some control, we get a lot back.

The session ‘Introduction to Google Guice: The Java Programming Language Is Fun Again!’ by Jesse Wilson was heavily attended. It started with an explanation why direct constructors are bad (harder to unittest and reuse). The common Java way is to use a factory, but this has some downsides (especially the factory version being shown). Google Guice acts as a super-factory, removing the boilerplate code, does more checks and makes it easier to write better code. The presentation described bindings, provider methods, binding annotations (requires a bit of code to define the annotation, but allows the compiler to check, which is not possible with string identifiers) as ways to set up the injection of dependencies. Guice also has the concept of scopes, which determine how many instances will be created, allowing a different/better way to create singletons. For injection, Guice supports constructor injection (the preferred way), method injection and field injection (which you shouldn’t use as it is hard to test). By leveraging Guice, it is easier to maintain modularity. It supports type literals, AJAX, servlets, AOP (method interceptors), and an introspection SPI (with Guice 2.0, cool for graphing dependencies!).

The final session for this year’s JavaOne was ‘How to Write a Distributed Garbage Collector’ (yet another session on deep VM internals). The session posed the hypothesis ‘algorithm design outweighs platform importance’. After the introduction of some concepts and terminology, the actual description of a distributed garbage collector was discussed. The base of the algorithm is a concurrent mark-and-sweep algorithm, where the objects to remove are those not reachable from root objects, not added to the graph while the marking phase was running and not in the Java VM heap. A better collector does generational collection, where a different definition for young and old is used (young is what has never been written to disk (yet), old is what is on disc even if it is in memory too). The generational collector considers only roots that are in memory. It has the benefit of avoiding disk I/O and can therefore run more frequently, but doesn’t clean up the disk (which must be done using a full DGC). The latest GC version takes care of server stripes. Having multiple servers cause that no single machine knows the whole object graph. The new algorithm appoints one server as coordinator and passes a token to other servers when encountering an outbound reference (in an implementation batches of tokens are sent to avoid flooding the network with small requests).

Another great JavaOne has come and gone. It was slightly less crowded, some of previous years sponsors were not present, but there were plenty of interesting sessions and the platform is alive as ever. Let’s hope there will be another JavaOne next year!

This morning’s keynote was presented by Microsoft: their first keynote ever at JavaOne. The lengthy (and a bit boring) introduction highlighted the participation between Microsoft and Sun in various areas. The part on interoperability (project Stonehenge) was more interesting and brought with more energy. The teams at Sun and Microsoft have been working together to ensure different layers of your application can be written in different languages, running on different platforms.

‘The New World: JavaFX Technology-Based UI Controls’ by the Swing team from Sun introduced the new controls in JavaFX. The goals for these controls are ease of use, and creating strong 3rd party control and theme markets. The design of components builds on the MVC pattern, but instead of the ideal where the parts communicate in a one way fashion, the skin/behaviour/model parts can all talk to each other. The JavaFX system now provides a more comprehensive set of UI controls (not complete though). The demo shows that these are really getting there. The team also introduced ‘Caspian’, the new look. It intends to provide applications with a fresh modern look, and be customizable using stylesheets. A demo showed how all components can be branded using just two colours. The library also includes basic charts (pie chart, line chart, area chart, scatter chart, bubble chart, 3d versions of bar and pie charts). Interestingly, the API has been designed to have developers specify the visual properties of the data, together with the data, departing from the Swing way of specifying those separately. Reason given is that FX makes it easy to generate the visual description from data retrieved from for instance a database. The layout system has also been changed: layoutbounds are now by default restricted to the shape (so shadow effects have no influence on the layout). Amy Fowler demonstrated the various concepts using a small demo application. Besides the programmatic layout, container managed layout now also starts taking shape. A few new layout managers were added, and hbox/vbox were fixed. A grid-based layout is still missing.

Related to the previous session was ‘Nimbus: Making Swing Look Sexy!’. Nimbus is a vector based look and feel, added to the platform in JRE 6 update 10. The presentation shows some details, but doesn’t always provide the reasoning behind those. It provided several ways to customize thing like the colour scheme, painters and UIDefaults.

After the last lunch break during which the pavilion is open, I went to the session ‘Where’s My I/O: Some Insights into I/O Profiling and Debugging’. The speaker did a good job of explaining the basic concepts and the history of I/O support in Java. His analysis tool, JPicus, looks very usable. It allows monitoring file I/O, providing useful on the amount of data read from files (including stacktraces of read operations), open files (plus stacktraces of the place where the file was opened), information on deletes, etc.

Brian Goetz and Cliff Click, in my opinion two authorities on this matter, presented ‘This Is Not Your Father’s Von Neumann Machine; How Modern Architecture Impacts Your Java Apps’. Goetz almost immediately went into hyperactive-mode speaking of CPU architectures (CISC, RISC). Then were addressed the reasons why we can’t go faster on serial execution, being: power consumption, the ILP wall, memory bottleneck and speed of light. The instruction level parallelism solution to improving serial performance uses pipelining, caching, multiple-issue, O-O-O, etc etc, which are all solutions that keep getting more complicated, while bringing not too much gain. The biggest issue is cache misses, which have a huge negative impact in the order of a few hundred clockcycles, quickly dwarfing the gains of ILP. To improve memory subsystem performance multiple layers of caches ared used, each getting a magnitude larger as well as slower. To make memory access faster, hardware manufacturers are working on new tricks. These things make it much harder to forecast the exact behaviour than the simple expectations us developers have, as illustrated by Cliff’s simulation of just a few Java instructions. The ultimate solution is to go multicore and not ‘waste’ more transistors on more complex schemes. A variant is chip multithreading, which runs a different thread every cycle, keeping the processor busy while waiting for data from underlying caches. But ultimately as developers, we need to change our mental performance models. We need to think in terms of data, not code. ‘Share less and mutate less’. And unfortunately there are still no good tools for the problems we face (related to the cache).

Another fast paced and entertaining session titled ‘Drizzle: A New Database for the Cloud’, was given by Monty Taylor. It described the goals for this mysql-fork that is intended to run in the cloud. It uses a new protocol, supporting built in sharding, UDP (for updates where you don’t really care if now and then an updated is missed), etc. They aim to reduce the amount of code in the core (down to 300Kloc at the moment). The architecture is very pluggable. Surprisingly security has been dropped by default, as most websites don’t really use it (credentials in the code) and don’t need to pay the cost of the authentication code path. Plugins are available for LDAP and HTTP AUTH.

The host for the afternoon keynote is IBM, presenting their vision, titled ’smarter planet’. They use ‘deep collaboration to drive innovation’, apparently meaning they pay their developers to work on opensource projects. One of those projects is Apache Harmony, the alternative VM. Another thing brought to the table by IBM was websphere extreme scale, providing a high performance caching product.

Java is coming to couch potatoes and the BOF ‘JavaFX Technology for TV: That Other Screen in Your Life’ introduced the details. It discussed the API, architecture, and device specifications. There was little time for demos, and many questions.

‘Creating Professional Rich Client Applications’ was next. Different ways in which layout can fail were shown. Absolute positioning should obviously not be used, but then there is still plenty that can go wrong: resizing containers, different look and feels and internationalization can all mess up the layout if not anticipated (or if you take shortcuts based on the way components look on your screen instead of considering how they should behave). Internationalization is supported in Netbeans out of the box, but enhanced options appear when you add the Swing application framework to your project. The same framework eases the creation of long running tasks. While starting a thread is easy, the framework provides standard hooks and easily ties in a progressbar. The SwingX library provides some additional components to use in your application. Creating new components was shown to be as easy as extending an existing one: then it is also draggable to the form editor. By editing the bean properties for the component, you can help users of the component by removing all unnecessary properties. The session then showed the beans binding API, especially the integration with Netbeans. If I’m not mistaken some of the material was already demonstrated at JavaPolis in 2006.

Today’s final session is ‘Java Programming Language Tools in JDK Release 7′. Many changes, such as modules, project coin, etc, required changes to the tooling. The talk provided details on the way new features like modules have been embedded in the compiler. Type inference bugs are being/have been addressed and the diagnostic messages will be better. A short but fierce discussion sparked when someone mentioned the need for XML output and to output only new warnings. Small changes to JavaDoc and javap were addressed as well.

The keynote this morning was hosted by Sony Ericsson. During the keynote, one of their developers was on stage, building a twitter client for mobiles in JavaFX. The part on the vision was probably less interesting to the audience than to the people on stage: it’s no different than the usual vision: more integration of devices to provide access and fun wherever you are. Their developer offering is about supporting the full stack of Java mobile MSA APIs, augmented with custom APIs and an application store (yet another one) where you can sell your applications to the world.

‘Extreme GUI Makeover (Hybrid Swing and JavaFX Technology)’ showed how to leverage existing Swing apps and use JavaFX to improve it. Swing is so mature and has many 3rd party libraries available, that it would be unwise to ignore it. Java itself is still (and will probably remain for the foreseeable future) very useful as the platform providing the data and threading functionality. JavaFX builds on top of existing Java libraries and allows effects to be easily created. The session rebuilds an application that was built in a previous makeover session, but that by now looked a bit dated, too. Lots of tips and hints were provided on how to create effects like rounded panels with shadowy edges, application stylesheets and animations.

With modularity being a key feature for the next Java release, I went to the session ‘Modularity in the Java Programming Language: JSR 294 and Beyond’. It clarified several things. Jigsaw is not part of the JSR, but uses the JSR. OSGi is well represented on the expert group (thus has influence, and this JSR is not a competitor to OSGi). The JSR is more generic than a single implementation, and intends to facilitate such systems, by defining concepts for dependencies, versioning and accessibility. The distinction of pure spec and implementation remains a bit vague due to all examples using Jigsaw. Dependency-wise the notion of a module path is introduced as a replacement for the classpath, which doesn’t scale. Versioning allows for changes that break existing code by having dependencies specify the version one depends on. Again, implementations decide on the way how to specify compatible versions. Accessibility introduces new keywords to specify the visibility of classes and methods.

‘Effective Java: Still Effective After All These Years’ was overly well attended, as usual. It started the same as last year with the PECS acronym, but fortunately provided some new content soon thereafter: a situation in which the compiler fails to infer the generics type, the typesafe heterogeneous container pattern, two element enums, vararg tricks, the correct use of ConcurrentHashMap and the serialization proxy pattern.

Next was a session on something a little different: ‘Programming Music for Fun and Productivity: JFugue and Log4JFugue’. It showed the complexity of the Midi library, and the simplicity of the JFugue library. I have tried Midi programming in Java once, and while producing a single or a few notes ain’t that hard, it is a lot of code. JFugue makes the translation of sheet music to a program, or creating rhythms, child’s play. It is also the foundation for the project Log4JFugue. This cool project turns log4j output to sound. The demo was absolutely fabulous. Patterns and changes in large amounts of logging output became apparent instantly.

The introduction of ‘The Ghost in the Virtual Machine: A Reference to References’ promised to make us garbage collection experts. It started with the stuff the GC cannot clean up (listeners, file handles, native memory etc) and some solutions (finally blocks, finalizers and the reference API). Obviously, the references API provides the most flexible solution. In a refreshingly high tempo with clear storyline we were taken on a tour of the various reference types, plus some of the classes of the Google collections library. The session ended with twenty minutes to spare after an example of the way a mark-and-sweep garbage collector works in relation to the different reference types. Closing the presentation, Bob Lee showed his geekiness even more by showing he generated the presentation from a Java program, in which the GC sweep graph was generated by generating a random object graph and a home-made mark-and-sweep algorithm: brilliant! :-)

After shooting some more tshirts into the audience, the afternoon keynote, ‘Mobility General Session (Part II)’, started on the reach of the Java (mobile) platform and JavaFX mobile. It showed demos of JavaFX combined with twitter, facebook etc, but also a PayPal application. I’m just not sure if I am impressed with the ‘just one week’ it took to develop that application. More typical American partnership presentations followed, before a demo was shown that takes an application from desktop, to mobile, to television. Pretty awesome!

The BOF ‘Grizzly 2.0: Monster Reloaded!’ did a good job of introducing the Grizzly project. It went over the history, components and users. The description of the new features in Grizzly 2.0 became a long list, with some useful explanations.

I choose ‘OSGi and the Enterprise Service Bus: Friend or Foe’ because the technologies do not seem to be directly related. The format of the BOF tried to get the interaction with the audience going: a panel was given statements and the question ‘truth or fiction?’, after which the audience could give their comments. Subjects discussed were modularity, versioning, service mediation etc. In the end, in my opinion, both goals were only partly successful.

The last BOF of my day was ‘Developing/Testing Accessible Java Technology-Based Applications in the NetBeans IDE’: either most people decided to go home early, or no-one is interested in accessibility, as the room was almost empty. The session went over different disabilities and tools to help overcome those. The presenters took their time to get to the description of JAAPI (the accessibility API). The demo showed how a Netbeans plugin can be used to test for accessibility issues. Another one for the list.

The official start of JavaOne! During breakfast the noises from the keynote-hall became audible through the walls.
The keynote immediately started with an announcement of project DarkChat: a massive chatsystem, built using JavaFX and project DarkStar. Jonathan Schwartz (wearing a suit, including a tie, what’s going on?!?) then highlighted some of the accomplishments of the Java platform. Guest appearances of eBay, RIM (blackberry), Sony (on blu-ray), Verizon and Intel. After this exchange of pleasantries between companies, the JavaFX platform got its share. And as expected: the JavaFX TV platform announcement. I found it strange that the JavaFX 1.2 release (which is said to contain Linux support) was mentioned only in passing. The demo by Nandini Ramani showed a sweet new editor/authoring tool for JavaFX content: all visual, including wiring of properties. In this demo Nandini pre-announced (oops!) the Sun store: store.java.com
It is then properly announced with James Gosling on stage. The store allows us developers to sell applications to all those billions of Java users world-wide. As a sidetrack Jagex got to demo their game RuneScape, and the game gets Duke’s choice award.
Scott McNealy got on stage, a great video of the history of Java, followed by tshirt throwing/shooting.
Alice, an 3D environment to teach students programming, also won a Duke’s choice award.
Scott remained on stage, commenting on the dip in IQ remaining on stage when James Gosling and the person of Alice left the stage. He breaks the subject many attendees are anticipating: Oracle and Sun. After a few funny pictures (Java advertisements on the Oracle ship of the America’s Cup Race), Larry Allison was invited on stage. He stressed the commitment of Oracle to the Java platform (all products, except the database) are Java based, and he’d like to see AJAX development replaced by JavaFX and is sure all developers will thank Gosling for giving us JavaFX.
After Larry left the stage with some signal flags spelling JAVA, and Scott said some final words, all developers rose to give the Sun team a huge applause.

Since cloud-computing is likely to be the next big thing, I attended the session ‘Java Technology-Based Cloud Computing with GridGain’. It promised to be little talk, lots of code. The talk started with a breakdown of grid-computing and cloud-computing, stacking their definitions. Then quickly moved on to coding different things using GridGain, showing how easy running tasks on several nodes can be when using GridGain to do so.

The session ‘Real Time: Understanding the Trade-Offs Between Determinism and Throughput’ started with an introduction to what real time is, and the system provided by Sun. Unfortunately, the theoretical part of the talk failed to bring clarification. The second part, a customer case study, did a better job of addressing the issues involved.

With hardly time for a break (that’s the way it is at the first day of JavaOne: they’re really hard on us :-)) the keynote started. It touched on the evolution of the platform and moved on to JavaFX, its latest features and architecture. Then they showed project Kenai. Yesterday I already go to know the project a bit, but this presentation added some cool additions: There is a Netbeans plug-in to interact with project data (such as issue tracking) from within Netbeans. Continuous integration is now also officially announced as part of Kenai (currently only as a limited beta). Mark Reinhold took over the presentation to discuss the JDK7 features. The focus is on modularity and multi-lingual capabilities. The modularity features (project Jigsaw) are intended to decrease download size for people without broadband (apparently more than a few), as well as supporting constrained devices. He performed a lengthy but very clear demonstration of the functionality provided by Jigsaw. The multi-lingual functionalities are provided by project ‘the Da Vinci Machine’, which works on the invoke-dynamic feature to improve the performance of dynamic languages. Project Coin is the umbrella under which small language improvements are covered. This addresses for instance the long-winded generics declarations. Other improvements in JDK7 will be type annotations, concurrency and collections updates, more new I/O, G1 garbage collector, compressed 64bit pointers, and more. It didn’t show the new date and time API, though. Robert Chinnici took over on the Java EE platform. Key features there are the focus on ease of use, profiles and pruning, as well as extensibility. Key technologies are JAX-RS, JSF and asynchronous servlets. The pluggable extension libraries functionality looks likely to reduce some of the configuration work that should reside with the libraries instead of the application. The EJB3.1 spec will improve the usability even further, and Bean validation API will help in validation. Too many new developments! Finally, Cluedin.org launched as the site to organize parties and get-togethers during JavaOne.

Bill Venners talk ‘The Feel of Scala’ presented the Scala language really nice, by showing different features of the language and the advantages or possibilities of those features. I have been playing with Groovy the last weeks and found it intuitive to work with and in some important ways superior to JavaFX, but Scala’s static typing means ‘play with Scala’ might move closer to the top of my todo list.

‘Asynchronous I/O Tricks and Tips’ covered ways to use asynchronous I/O. The session covered many of the classes/interfaces of the API. It touched on the way to retrieve the result of an asynchronous I/O operation (one way is to use Future objects (the ones from java.util.concurrent), while the alternative is using a CompletionHandler), as well as the different classes for both file and network I/O. The second part discussed Grizzly and its use of the new API, plus the issues encountered.

Although I’m usually involved in JavaSE projects, some knowledge of developments in the EE space is helpful. The session ‘A Complete Tour of the JavaServer Faces 2.0 Platform’ provided info on the brand new version of JSF. The spec now provides support for AJAX, in an attempt to bring together the best elements from existing solutions in the various *faces libraries. Performance has been improved using partial state saving. There’s lots more: check out the new spec: changes are easily identifiable due to the colour coding used.

After half an hour, just time enough for a quick bite in the pavilion and getting an espresso-fix at Starbucks (necessary by then), the evening program with Birds of a Feather sessions starts. ‘Using Embedded Containers for EJB 3 Technology-Based Components’ looks at some reasons and options to embed an EJB container in your application instead of the other way around. The key difference being who gets to control the VM. The primary use-case is unit-testing, and it shows that this can really decrease the time spent in the regular build-deploy-test cycle. The second use-case is adding EJB3 functionality to a servlet container. This requires minimal configuration, is lightweight and can be used to transition from a servlet container to a full application server. The final use-case is embedding EJB3 in Swing/command-line applications, which might be fun to try sometime.

‘Inside the Sun Java Real-Time System’ provided details on the real-time Java system. It provided an excellent look at what real-time Java is intended for, its history etc directly from the experts.

The final session is the session with the JavaPosse. This was great fun, but for the details you’ll just have to watch for their JavaOne episode! :-)

The week Java-developers around the world are looking forward to is here again: the week of JavaOne! As usual, the week kicks-off with the Community-one.
It is very clear recession has hit hard: not only have some of the familiar stores in San Francisco disappeared, but the Moscone is less crowded than other years, feeling a bit of empty.
The keynote of today is not doing a good job of energizing the attendees (and from what I hear it is not just how I feel after yesterdays nice wine-tour with the Dutch Java User Group). It focusses on the importance of the community, highlighting the large number of students present, before going to cloud-computing. It shows how easy it is to set-up a virtual network consisting of all the nodes you’d be expecting in your network, all instantly available after swiping your creditcard. A lengthy talkshow-style part of the presentation goes into the new parts of OpenSolaris (dtrace, the new network stack, ZFS).
The remainder of the day was filled with various sessions.
Guillaume Laforge talked about the latest version of Groovy in ‘What’s New in Groovy 1.6′. It’s quite a list! Especially the new meta-programming abilities to change code right before compilation seems to be useful to reduce the codebase in certain projects.
The session ‘Moving Forward: High-Performance Application Development in a Multicore World’ was shaped as a platform discussion, preceded by a short presentation from which was clear that this was AMD sponsored. The ‘discussions’ were pretty tame. Lots of terms were mentioned, most not clarified (not even after asking if the audience understood). On the other hand, that’s what a todo list is for, and a couple of new terms got onto mine.
The session ‘Your Code, Your Community . . . Your Cloud: Project Kenai’ introduced this new project that is basically a project hosting service hosted by Sun. The twists brought by this service are the focus on sharing, participation and connecting. It also intends to be customizable in choices like the repository and issue tracking services being used. Look like a lot of fun!
The start of,the session ‘Project Darkstar: Open-Source Technology Powering New Worlds’ focussed primarily on the business generated in the massive online gaming industry. Chris inserted lots of fun stories. The second part of the talk discussed what project Darkstar is, reasons for using Darkstar and a few bits of technical details. The final part on project Wonderland was unfortunately rushed.
‘Practical Groovy Domain-Specific Languages’ starts with a treatment of what DSLs are and that they are actually all around us (chess notations, sheet music, etc). The talk highlights several features in the Groovy language that can be used to create new languages.
The final session of my day, on Gridgain, of which I had high expectations, got cancelled due to the speaker not showing up. The remainder of the time was therefore spent in the pavilion, gathering ‘goodies’ and learning some about the products of the vendors, as well as the FIRST robotics competition.
The evening ended with a marching band opening the pavilion reception, as well as the OpenSolaris and Sun Cloud party, and the start of an entertaining evening program.