The first session I attended on day 2 was called "Architecting for Performance and Scalability", where representatives from Terracotta, (Oracle) Coherence, GigaSpaces, etc (and eBay) came together to talk about the different approaches to building scalable systems. It was surprisingly civilised and it was interesting to compare and contrast each vendor's approach to dealing with the scalability problem. Here are my takeaway points from this session :

• On average, the audience thought that they could squeeze 2x performance out of their existing systems if given a couple of weeks to tune it. If you need any more, you need to architect/design with that in mind. In other words, you need to design in scalability from the start.
• Ultimately, many of these decisions are economic in nature. It's okay for a business to demand ultra high scalability, but they will pay for it in terms of hard cash and time to market. It's all about trade-offs.
• Continuous performance testing is an important thing to do if you're building systems that are performance critical. The implication of this, of course, is that you *have* something to test, which for me points to an iterative development approach and an executable reference architecture as early as possible.

The next session I attended was called "A Tale of Two Systems", which basically presented a picture of what happens when you do and don't design your software. Anybody experienced in software development won't have seen any surprises here, but it was nice to see the good and the bad contrasted in a very down-to-earth way. There was a definite agile spin of all of this; with talk of flat team structures and a distribution of the design responsibility throughout the team. In fact, Pete stated that "he'd never worked on a project that needed an architect". While these approaches work well for small and/or simple projects, I'm still of the opinion that *some* architecture needs to be performed up-front and that somebody needs to take ultimate responsibility.

Following the talk about software design was a talk about user interface design, entitled "User Interfaces: Meeting the challenge of simplicity". This session looked at the art of designing user interfaces so that they appear simple to the user, and that how making even the smallest of changes can have a huge impact. One of the most interesting parts of this session was that it almost completely paralleled the session that preceded it; in terms of talking about agile development, feedback, simplicity, you aren't going to need it (YAGNI), etc.

The final session I attended was Neil Gafter's look at the new features that are being considered for Java 7 and beyond. I've not been following this too closely and it was interesting to catch up with it all. One of the things that struck me most was that the Java platform JSR hasn't even been started yet and that Sun don't seem to have enough resources to do everything that they want to (apparently JavaFX is more important?). I was under the impression that major releases of the platform were going to be on an 18 month cycle, but clearly that's not going to happen. I also don't necessarily understand where/how the open source stuff fits into all of this. There are some nice smaller features being considered for Java 7 (multi exception catching, easy exception rethrowing, the ability to switch on Strings, etc) but part of me thinks that maybe the bigger language changes (e.g. closures) shouldn't be implemented. Perhaps it might be better to stop making big changes to the Java language and start putting more effort into something else (e.g. Scala, Groovy, etc).

All in all, another great day at the conference and some interesting discussion in the bar afterwards.

Add a comment

Posted by Simon Brown on 14 March 2008 08:46:00 GMT #

Erich Gamma's keynote got the QCon London 2008 conference underway, where he talked about his experiences with the Eclipse project over the past seven years. There were a few interesting points during this session but I'm going to write about those separately. The thing I will say is that it's always good to hear the real-world stories about iterative development - in this case, the Eclipse team work on 6 week iterations and don't necessarily have a fully shippable product at the end of them. Erich wrapped up the keynote with a demo of the new Jazz platform, which pulls together all of the tools in your standard development suite into a fully integrated workflow. This looks like a rehash and enhancement of Rational's Unified Change Management (UCM) platform using Eclipse as the front-end. That might not be totally accurate (I think I saw a Subversion bridge in the slides), but you get the point. Certainly worth a look, although the "commercial open source" thing confused me.

As for the main sessions, I stuck to the banking track for the first day and that turned out to be a good decision because there were some really interesting presentations.

First up was John Davies who jumped in at the last minute because the speaker for that slot couldn't make it to the conference. Instead of a session about domain specific languages, John presented an overview of technology within the investment banking space. It was a really interesting talk and very nicely summarised many of the trends that we've seen over the past few years (e.g. compressed on the wire message formats rather than XML, etc). The key takeaway point for me was that you need to design for scalability. This is one of the reasons why I think it's important that software systems have an explicit and intentional architecture, with somebody taking responsibility for it.

Next up was Iain Mortimer who presented a session that was entitled "Keeping 99.95% uptime on 400+ key systems at Merrill". Although this was a relatively interesting session, I do think that the title was misleading. Instead of talking about how the 99.95% availability target was being satisfied, Iain talked about how Merrill monitored those systems, and particularly about the rules that they used to monitor those systems. Iain said that their availability requirements allow for 18 seconds of downtime per day, but didn't go into detail about any failover or recovery techniques that allowed them to meet that goal. So in that respect, the session was a little disappointing, although it was interesting to hear about the challenges of monitoring 400 systems across a global organisation in a consistent way. The key takeaway point from this session was that you need to design systems with monitoring in mind, which I completely agree with.

Third on the track was Bertrand Delsart from Sun, talking about the real-time Java specification. Although there were a couple of banking examples thrown in, this session was essentially a generic RTJS talk. The closest I've got to real-time Java is BEA's JRockit JVM with deterministic garbage collection but, as Betrand said, garbage collection is only one part of the story - Java apps also suffer jitter from the JIT compiler kicking in at unwanted times, etc. While this isn't something I'll probably try out myself (Sun's real-time Java VM only runs on Solaris 10 at the moment), what they've done is built a framework onto which you can build your applications where you decide which parts of it are regular Java, soft real-time or hard-real time. My understanding is that the hard real-time stuff is made possible by utilising the underlying OS real-time threading and some clever use of non-heap memory spaces, in addition to appropriately scheduling the garbage collector so that it doesn't interfere. Cool stuff and I think we'll be seeing this pop up in the banking industry soon.

Next was Betfair talking about their new Tradefair platform and some of the challenges that they need to overcome to provide a highly scalable, highly available trading platform. Again, there was some interesting discussion of the problems and high-level solutions, although many people (myself included) came out of the session not really understanding what they had done. They were very sketchy with the details and I'm left wondering why they couldn't have implemented their system using something like JavaSpaces (what they described sounded like a JavaSpace - put many things in and match them up). The thing I did like about the session was their openness in admitting that none of the solutions were ideal (all had trade-offs) so they had to pick the one that fitted their needs the most.

The last session of the day was a talk about LiquidityHub, a new trading platform that was built from scratch in just nine months. As a disclaimer, I work at Detica and have many friends that worked on the project. Having said that, this was one of the best sessions of the day. It presented an overview of the business problem, an overview of the chosen architecture and a look at how some of the technologies were used to build the platform. This project shows that it is possible to build a high volume, low latency platform with mainstream Java-based technologies. BEA's JRockit JVM was used to reduce the jitter of the Java runtime, making it possible to achieve a service level agreement stating that messages should pass through the platform in under 100ms. With its good coverage of everything from the business problem down to some of the implementation details, this was a great way to end the first day.

Add a comment

Posted by Simon Brown on 13 March 2008 09:32:00 GMT #

The Pebble 2.3 release is available to download from SourceForge and includes quite a few small new features and fixes, some of which I've written about before. Here's the full list.

• Added a "friendly" URL for the aboutAuthor action (/authors/username/).
• About author page now shows the author's profile and their recent blog entries.
• Added an RSS/Atom feed for individual authors (/authors/username/rss.xml|atom.xml).
• Added e-mail subscription functionality, where readers can subscribe to new blog entries via e-mail.
• Enhanced log summary reporting (e.g. statistics view showing a breakdown of the total requests and unique IPs for newsfeeds, page views and file downloads).
• Added log summary by country.
• Fixed date formatting problems with Atom feeds (they weren't being formatted in UTC).
• Normal themes can now be used for the multi-blog pages, with the theme being switchable via the Pebble Properties page.
• A static page can now be configured (via blog properties) to be the home page for a blog.
• Minor HTML cleanup and tweaks to theme.
• Added a GZIP compression filter to reduce page loading times.
• DWR scripts are now cached to reduce page loading times.
• Fixed a problem where JavaScript would be served up when logging in to a private blog.
• Fixed problems with unit tests failing in non-English locales (patches from Frédéric Chuong).
• Moved admin links from the sidebar to the top of the page.
• Separated out blog security configuration from the general blog properties.
• Pebble now uses the ServletContext for getting MIME type information when serving up files.
• Added a user preferences page and moved configuration of the rich text editor for blog entries/static pages (on/off) to be user specific.

If you have any feedback, please use the pebble-user mailing list. Have fun!

Responses[1]

Posted by Simon Brown on 07 March 2008 23:00:00 GMT #