dow.ngra.de

The best talk I’ve been to so far is TerraCotta’s introduction and patterns. Ari is a good speaker with passion, intensity and speed that I admire (though some others might find the talk a bit too informative).

I’ve heard about TerraCotta before, but this was the first time I got to know the details. The basic functionality that they claim is transparently clustering your objects, so that all changes on one JVM are visible in all the rest.

Turns out they instrument GETFIELD/PUTFIELD instructions and propagate updates among the servers. It is easy enough to do for the basic types and they have special support for strings and collections, but they also need to assign identities to objects so that updates to reference fields would change only the reference to an object with the same identity. For that they instrument constructors to associate identities with objects and reconstruct identical graphs on different JVMs. Of course, like JavaRebel, they also need to instrument reflection.

In addition to that they instrument MONITORENTER/MONITOREXIT instructions to acquire distributed locks instead of local ones. There are some quirks here that I’d be interested in finding out, e.g. how do they deal with locking the same monitor in the code not managed by TerraCotta. The likely answer is that they don’t :)

An interesting question to ask here is whether we could use STM. Basically TerraCotta needs to collect changes to the objects anyway, so to enable optimistic locking instead of pessimistic they’d have to add two things:

• A way to revert changes done to objects. A pretty trivial thing to do.
• A way to unwind the stack if the commit does not succeed. This is not easy, but can be done with an approach like Geert Bevin used to implement continuations.

There is also a question of what to do when the critical block does global side-effects. IMHO you can just delegate this to the user, so that he has to explicitly enable optimistic locking at a particular spot.

In fact when I think about it, this approach would make some sense even without distributivity. For highly concurrent code such optimistic concurrency would create a great performance win (as indicated by Azul). Of course you have to trade it off with the instrumentation costs, but for some applications the performance win might be tremendous.

When I asked Ari about optimistic locking he indicated that they have some experimental support in the works, but there are still some problems to overcome.

Brian Goetz gives a talk on different approaches to concurrency in programming languages.

Starts by incrementally introducing race conditions, synchronization and deadlocks. Hasn’t mentioned lock starvation and mentioned volatile only once. Eventually gets to a point that OO encourages hiding implementation details, whereas for concurrency you need to know them. This makes threads clash with OO (doh!). Still a bit softcore for my taste.

Brings in the STM. It’s implemented by Azul in hardware (they have committable cache memory) and, of course, optimistic rollback is much much faster than pessimistic locking. Transactional memory is a cool thing, but in a side-effect language everything cannot be rolled back so easily.

Finished with a quick overview of other concurrency techniques, last is Actors. In the end no actual info on what could go into the language, just a brief overview of the approaches.

In the end the Clowd track contained a lot of talk and little useful information. Amazon was the most interesting in the end.

Google guy talked about a unified Atom-based API to their services. It is a nice feature, but there was little real information to add to that description.

Yahoo showed off the pipes. It was cool to play with, but I both managed to crash it and couldn’t get very far with printing a map of Tartu with restaurants on it.

The panel was discussing whether transactions are necessary to no end. Really was a great cloud of fog. Hopefully tomorrow will be more substance.

Amazon web services is an offering to host your data and software at Amazon with massive virtualization and an interface over web services.

The first part of the talk is about S3 file hosting, which is done through a Firefox plugin (which I mistook for FireFTP first). You can upload files, assign ACLs, get the URL for publishing and pay proportionally to storage used, requests done and bandwidth used (all three have assigned fees). Nothing technically fancy, but cool nevertheless.

The next part is about EC2, which is a virtual server on-the-fly renting. You basically store a (special) disk image on the S3 service and then boot from it a number of virtual servers. You get root access to your servers and pay per hour of use. You can add/remove servers both programmatically and from a Firefox extension.

The next part is about SQS, which is a queuing communication service. Basically the main use for that is for communication among the EC2 servers to enable scaled processing.

The last part is SimpleDB, which is a simplified database service. Basically provides a fully indexed collections of key-values pairs (multiple values!). It’s kinda like a flat JSON (one object per row, values can be arrays). Provides a simple query language (isn’t this very similar to CouchDB???). Useful for services that don’t need too complex queries.

In the end a quick overview of payment services. One cool thing is that you can use DevPay to charge your users for the services hosted on S3/EC2. Nice stuff, but only applicable in the US in the foreseeable future.

Lastly I asked whether there is any load balancing provided by Amazon, but turned out that you need to set up your own and add a registration call to the server instance startup.

Generally the talk focuses on the business side, whereas I’d like to know how do they actually implement the services.

Erich Gamma gave a talk on Eclipse, which is a variation on the theme he’s been doing for some time now on various conferences. The main difference to the previous years is the part about Jazz.

One interesting thing I didn’t know was that Eclipse now includes API tools that allow to annotate APIs with version information and fine-grained access control and then make Eclipse IDE check these for you.

So WTF is Jazz? Explanation starts with great clouds of fog: “integration”, “community” and even “Eclipse experience”. Scary diagrams with a lot of arrows. Starts sounding like Twitter on steroids — you can follow events or channels, events are produced from both web and Eclipse plugins. You can also track basic statistics like defect progress. Doubt you can get updates to IM or SMS, though :)

I wonder if you could actually build something much simpler on top of Twitter? Like just produce artificial users you can follow and stay up-to-date on team happenings. Jazz sounds like something overcomplicated for a simpleton like me.

OK, there’s also some data mining you won’t get with such a simple setup. The tag cloud is of course present, as are a lot of progress bars and there is integration for builds and automatic tests. Also does planning and reflection, though I still think you can do a lot simpler (read: whiteboard!) with a smaller or non-distributed team.

In the end Jazz might be very cool, but it’s a complex tool and you need to really get in to it to understand whether it’s worth the hassle. It also looks like it can impose a lot of ceremony on your process, though it may be possible to use just a fraction of the features Erich showed.

Some misquotes:

• “Frameworks are like exhibitionism with a sea of classes” — on implicit dependencies among classes
• “There are four layers of preference mechanisms in Eclipse” — when commenting on API evolution
• “If it hasn’t shipped it doesn’t exist” — referring to the secrecy surrounding Eclipse before it went Open Source.
• “My mother can see the bugs I have?” — commenting on developer reaction to going Open Source.
• “Milestones are like a soap opera” — about people looking at New and Noteworthy