I’ve been meaning to post this for a while after a long trip to NY and the Spring Experience in Hollywood, Florida. This was a fairly nice and long trip, with my kids and wife joining me – including some of the sessions in the Spring conference 🙂 Few words about the the Spring
This year was the third time this event was held. It took place in Hollywood, Florida, in a nice venue, the Westin Hotel by the beach. Obviously, the focus of the event was
on Spring-related technologies, and unlike previous years, this year most of the
sessions were given by the SpringSource team. The event was well attended (500-600 people) and was well organized. The main sessions were held during Thursday
and Friday. The sessions started as early as 9:00 AM and lasted until very late in
the evening (on Friday we finished at 11:00 PM!). I thought that it would be useful to share with you some of my notes from the event. The notes are listed in chronological order.
Keynote Presentation by Rod Johnson
The keynote was held during Wednesday evening. Unfortunately, I arrived only after the
keynote, but I heard from my colleague Geva that it was quite interesting. Rod’s keynote is not yet available online, but you can view the one he gave at SpringOne earlier this year here. Note section 33, where Rod mentions
GigaSpaces at length as one of the companies building their product on top of Spring.
The event was a good opportunity to launch and promote the developer contest GigaSpaces is running. There were quite a few people that came to us because a friend forwarded an email to them about this competition, which is a good indication that word about the contest is spreading quickly. (See earlier post about this contest here).
presentation – Rapid
Fire: The Compass Enterprise Search Engine Framework
Shay Banon gave a Compass presentation on Thursday night at the same time I gave a presentation on testability in distributed environments. Based on the number of attendees and feedback from Shay’s presentation it
went quite well. Shay also presented his integration work between Compass and
GigaSpaces in which he used GigaSpaces to provide the virtualization layer for Lucene indexes and in that way scale-out Lucene! Can’t wait to give it a try. Unfortunately, I couldn’t see Shay in action, so I can’t speak more about it, besides pointing you to his online presentation at SpringONE earlier this year. One interesting anecdote is that part of the development of this integration was actually done during The Spring Experience – something I noticed about Shay is that he is at his best when he codes in conferences:))
Testability presentation: Rapid Fire: A Framework for Testing Clustered Applications
Owen Taylor joined
me on this presentation and helped make this session entertaining as well as informative — something that was quite important at such a late hour. The focus of the presentation was on the difference between testing a
distributed application and a client-server environment. From a project planning
perspective the main risk lies in the non-functional requirements, such as
scalability and performance. Yet if you look at how projects are planned in real life, we often see that the project plan does not address these types of risks.
Quite often even the machines running system
tests are not provisioned to be available to the development team until very late in the process – this may explain why it is so difficult to apply concepts such as continuous integration and agile
development to distributed
computing. Most existing tools and methodologies are tailored for
functional unit testing. As we experienced ourselves in the development of the GigaSpaces products, there is a need for new development and testing methodologies, and tools for supporting this type of
environment. In this presentation I used slides from Guy Nirpaz (EVP of Development @ GigaSpaces) and one of his team members (Igor Goldenberg).
The presentation describes how we handle this challenge in the GigaSpaces development process. This
was my first time talking about GigaSpaces
development as a case study, and not about our product. Guy gave a similar presentation at JavaPolis, which took place earlier that week.
I found that this topic opened up a new kind of dialog. This time we were on the same side of the fence as the audience. I also noticed that there is huge demand for these types of testing tools, not just from our
customers, but all over. Although the session was quite intimate, those that came seemed to be engaged. Several people approached me the next day and wanted to dive more deeply into our product. This included a guy from the Patent Office who said that they are facing huge scalability issues on their site and are dealing with the same testability issues I was describing in the session. I explained that while our testing framework is not yet available for public use he can start building his own testing framework using a master-worker pattern with our free Community Edition and also run it on Amazon EC2 for scalability testing.
Three Steps Presentation: Scale
Out Your Spring Applications in 3 Simple Steps
This presentation was held on Friday, right after lunch. The session was well attended. Owen Taylor joined me in this presentation as well and helped both with the demo and the Q&A session. The presentation seemed to be very well received. The main difference in this presentation compared to previous ones that I gave was that in this one I focused on showing how you can implement the principles of scaling in evolutionary steps by introducing the right set of abstraction techniques, thus avoiding major code changes or architectural changes. As the presentation was 1.5 hours long we decided to use the our Microsoft Excel demonstration, in which we use Excel as a rich client front-end to a market-data server running Spring-based processing-units that process the market-data events.
The demo illustrates the deployment and scaling of this Spring-based application, and how scaling and fail-over can be made easy. It also demonstrated how this type of technology can be
easily integrated with mainstream frameworks in both Java and .Net, and even combine the two together! We got really good feedback on the presentation and lots of questions came during the session itself on Persistency as a Service, as well as the notion of Space-Based Architecture. I picked up a couple of blog posts by attendees of this session here and here.
The keynote panel was held late on Friday and was quite interesting. For me this was a good opportunity to catch up on new developments in Spring, as I didn’t have the chance to attend most of the other sessions. To sum it up, I think that the main points are:
- Spring 2.5 provides simplified annotation support, which addresses the complex XML configuration required to build Spring based applications. See more details here.
- IDE integration – enables quick navigation from the IDE to
the documentation and reference examples.
- OSGi support – enables late bindings of service components. In the session, Adrian Colyer used a web application to demonstrate how you can plug-out a service component from the web application and then turn it on while the http request is blocking. When you turn the service back on, the wiring happens behind the
scenes enabling the web http request to be completed without error (but with a small hick-up). This enables the application to replace certain components of the application without brining the entire application down. See more details here: So what’s the deal with Spring-OSGi?
- Spring Integration – This seems to be the Spring version of Mule – see more details here: Spring Integration: a new addition to the Spring portfolio
- Spring Web Flow – Spring is putting much more focus on web support through their extended support for REST and JSF. Keith Donald mentioned Grails as his favorite web platform.
- Spring security (previously known as Acegi) – introduced a significant simplification of the configuration and security setup – see more details here: What’s New in Spring Security 2?
missed one or two points but the above seem to be the main ones.
The extreme scalability panel started at 9:30 PM and ended at 11:00!
The session was moderated by Rob
Harrop. The panel included Wayne Lund from Accenture, who did a lot of work with Spring Batch, and Patrick Peralta from Oracle. Unfortunately, Billy Newport from IBM was scheduled to participate but had to leave earlier due to a personal reason. After a few questions and answers in which we discussed some of the challenges of bringing grid computing to the mainstream, an interesting discussion started about the concept of middleware virtualization, i.e., the ability to map existing APIs transparently to the grid and what should be the right level of abstraction to which virtualization should be applied (API or JVM).
Rob made a few comments about the concept JVM level virtualization. He was very explicit in his comment that distributed computing shouldn’t be dealt with at
the VM level, and that it doesn’t make any sense to call synchronize methods that
will start a whole distributed session.
Spring Experience was a good chance to meet colleagues, such as Rod Johnson, Adrian Collyer, Bob Lozano and the guys from Alpha CSP. It was also the first time I met Billy Newport in person and we had quite a lengthy and interesting discussion.
Now you don’t think that we could spend all this time in sunny Florida without having a bit of fun too, right? Thanks to Jody (the camera man) we had a nice chance to sail on his fast boat, which he named Sira (means "boat" in Hebrew) during Friday afternoon, just when the sun set! The picture below (of Owen taylor) is dedicated to all of you who are probably freezing right now in New York and elsewhere:) Checkout the rest of the pictures as well.