The biggest difference I found was with the Home and End keys and the Delete Line mapping. So here’s how to make TextMate work more like IntelliJ.

Change Home and End keys

From this old blog post:
Create the custom KeyBindings folder (if it doesn’t already exist):

mkdir ~/Library/KeyBindings

Create a key bindings file called DefaultKeyBinding.dict in this directory with the following content:

{
    /* home */
    "\UF729"  = "moveToBeginningOfLine:";
    "$\UF729" = "moveToBeginningOfLineAndModifySelection:";
 
    /* end */
    "\UF72B"  = "moveToEndOfLine:";
    "$\UF72B" = "moveToEndOfLineAndModifySelection:";
 
    /* page up/down */
    "\UF72C"  = "pageUp:";
    "\UF72D"  = "pageDown:";
}

Change Delete Line mapping

Go to Bundles > Bundle Editor > Show Bundle Editor.
In text bundle, change Delete Line from CTRL+K to CMD+DELETE.
In the text bundle, Delete to Beginning of Line macro, click the X to remove the same binding.

I went to Le Mans on the weekend. It was a bloody incredible experience.

After meeting up with a couple of BMW GS’s, a Suzuki Bandit and a Harley(!) at 4am on Friday morning we got the 6am ferry from Dover to Calais and then took some nice roads south to Le Mans arriving at the circuit at about 2pm.

Staying in the campsite was unlike anything I have ever experienced before. Anyone who’s been will know what I mean. For those who haven’t, you need to imagine something like Mad Max. The campsite is between the airfield and the circuit but you can barely hear the noise of either the aircraft or the race track due to the constant insane revving of motorbike engines in the camp. This literally goes on without stop from Thursday until Sunday. All through the day and night bike engines are screaming in torture being held at the limiter and having their cut-off switches flicked to produce flaming backfires. The French call it the Rupture. The noise is deafening. Some take the cans off their bikes and some attach home made garbage can trumpet attachments for extra awesomeness.

Other features of the campsite are flares, fires and massive amounts of alcohol and drunkenness. Oh and dust. Lots of dust that mixes with the smoke of the campfire and the early morning mist to produce a kind of smog that coats your bike/tent and floats across the circuit.

Oh yeah, the circuit. That’s right. The race that everyone is supposed to be there for. The racing is incredible. I do not know how these guys do it. It’s pretty surreal. As a spectator you watch the start and several laps. Then maybe have a wander round the circuit, watch a bit more and catch up on the positions then head back to camp for dinner. After dinner you wander back over to the circuit, and those guys are still flinging their bikes around the track, lifting the front wheel through the Dunlop bridge and overtaking into corners. Then you might watch a bit of the rock concert and then head back to the track. They’re still racing. It’s getting late so you head back to camp for more drinking / general madness and try to get a couple of hours sleep over the noise of the rupture. You get up early to watch the sunrise over the circuit AND THEY ARE STILL RACING! They haven’t slowed down AT ALL! An hour or so later you head back to the camp for breakfast / beer and later on walk back to the circuit to watch the final few hours of racing. OMG THEY ARE STILL GOING FLAT OUT! I don’t know how they do it for 24h. I know the riding is split between 3 or 4 riders but it’s still insane.

The whole thing was unreal. I got back home at 2am on Monday morning and I still haven’t fully recovered from the weekend. Oh and the French loooved the Daytona. I’m not exaggerating when I say everyone who walked passed my bike in the campsite either turned to gaze at it or more often stopped and discussed it with their mates. The Harley barely got a glance. I only saw a couple of other Daytonas although there were a few more Streets.

I’ll add some photos I took when I have had a chance to look at them but here’s a great video of this years race.

A few pics. Full gallery is here.

• Strings in switch
• Collection literals
• <> (generic type inference)
• Multicatch

catch (ClassNotFoundException | NoSuchMethodException e) {
    // Do something
    throw(e);
}

Bill Pugh’s session was as popular as expected for his talk about defective code and how static analysis with FindBugs can help. I’ve heard Bill talk about this stuff before but this time he was emphasising that not all bugs are equal. All code has bugs but some mistakes don’t really matter.

Google’s code has over 1000 null pointer bugs but few if any NullPointerExceptions in running code are caused by these. You need to determine which bugs are worth your time to fix.

The most important bugs are generally those which can cost you money on the first day they manifest themselves and those bugs that occur silently. This is why Bill is a fan of runtime exceptions; if something unexpected happens, you want to know about it.

Devoxx is held in a massive cinema complex and so after all the talks today the organisers put on a showing of The Social Network, a movie about the founders of Facebook. I really enjoyed the film. All the performances were great and I really liked the soundtrack by Trent Reznor. You don’t need to be a geek to enjoy this film. I don’t know how much of it is actually true but it paints an interesting picture of Mark Zuckerberg and draws nice connections between our concepts of ‘friendship’.

After going over some problems you can face when caching (stale data, thrashing, distributed caches) and different caching patterns he introduced the declarative caching of Spring 3.1.

It uses AOP and can be declared on methods by adding the @Cacheable annotation. This annotation caches a method’s return value using it’s parameters as the key although this can be customised.

Eg:

@Cacheable
public Owner loadOwner(int id);
 
@Cacheable("owners")
public Owner loadOwner(int id);
 
// Using Spring expression language
@Cacheable(key="tag.name")
public Owner loadOwner(Tag tag, Date created);
 
@Cacheable(key="T(someType).hash(name)")
public Owner loadOwner(String name);
 
// Only cache on condition
@Cacheable(condition="name < 10")
public Owner loadOwner(String name, Date created);

The @CacheEvict annotation invalidates the cache:

@CacheEvict
public void deleteOwner(int id);
 
@CacheEvict("owners", key="id")
public void deleteOwner(int id, boolean saveCopy);
 
@CacheEvict(name="owners", allEntries=true)
public void batchUpdate()

You can also use your own stereotype annotations. Instead of spreading @Cacheable everywhere:

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Cacheable("results")
public @interface SlowService {
 
}
 
@SlowService
public Source search(String tag) {...}

Spring is not a cache provider itself. You plug in your own cache provider (ehcache, JBoss Cache, etc).

His talk was about microbenchmarking – measuring the performance of a small piece of code as opposed to profiling an application.

In the good old days performance could be estimated simply by counting program instructions. Now it is simply impossible to do this because of the ‘abstraction gap’.  As code has become more and more complex it has become harder and harder to estimate and measure the performance.  Complexity and predictability are inversely related.

Even benchmarking code doesn’t really work with consecutive runs often showing a variance of 20%. The code and systems are so complex nobody really knows where this variance comes from.

The solution is to run a bunch of JVMs in sequence and then statistically analyse the data (mean, median, standard dev, etc).

Basically, benchmarking is really, really hard and most benchmarks are seriously broken. Either the results are unrelated to the test or the error bars exceed the measured values.

Caliper is microbenchmarking framework from Google which can help.

He seemed to be leaning toward Fantom as the language of choice before delivering the punchline that the best candidate for the Next Big Language might be a backwards incompatible version of Java itself.

I think I agree. Oracle should get rid of all that legacy crap in JDK 9.

I have already had some experience with Cassandra at both my previous and current jobs but it was good to go over the principals of Cassandra as well as seeing an example application deconstructed.

Cassandra’s strengths are:

• Scalability
• Reliability
• No single point of failure
• Multiple data centre support
• Integrated Hadoop support (lets you run map reduce jobs on data in Cassandra without any ETL)

Of course Cassandra is not ACID and has limited support for OLTP ad-hoc queries. However, companies that have really scaled traditional RDBMSs like MySQL or Oracle end up dispensing with these features anyway in order to achieve that scale.

Jonathan had an interesting quote from Twitter:

It used to take 2 weeks to perform an ALTER TABLE on the tweets table

This is  definitely something I can sympathise with. If you don’t plan ahead it can be easy to suddenly find your tables are so big they cannot be changed without serious pain, downtime or both.

When designing a relational schema we tend to think of objects and relationships. With Cassandra we need to think of objects and the queries we want to run against them. For each type of query you will need a column family (something like a table).

When choosing a key for rows, a natural key is best. If you need a surrogate key, use a UUID as integers may create collisions due to the distributed nature of Cassandra. Version 1 UUIDs can be sorted by time but if you don’t need time ordering, use version 4 UUID.

Using Thrift directly should be avoided at all costs in favour of higher level libraries like Hector. There is a JPA implementation called Kundera but this is based around Lucene so unless search is an important part of your application it may not be the best choice.

The afternoon was spent learning what’s new in Hibernate with Emmanuel Bernard from JBoss.

Fetch profiles can be defined and chosen at runtime, eg:

@Entity
@FetchProfile(name = "all",
    fetchOverrides = {
        @FetchProfile.FetchOverride(
            entity = Customer.class,
            association = "orders",
            mode = FetchMode.JOIN)
        @FetchProfile.FetchOverride(
            entity = Order.class,
            association = "country",
            mode = FetchMode.JOIN)
})
 
public class Customer {
    @Id @GeneratedValue private long id;
    private String name;
    private long customerNumber;
    @OneToMany private Set<Order> orders;
 
// standard getter/setter
}
 
Session session = ...;
session.enableFetchProfile( "all" );  // name matches @FetchProfile name
Customer customer = (Customer) session.get( Customer.class, customerId );
session.disableFetchProfile( "all" ); // or just close the session

A lot of time was spent on the Criteria API which lets you write object oriented, type-safe and strongly typed queries.

Hibernate Search provides lucene-based full text search for Hibernate and looks quite neat. You get transparent index synchronisation and support for clustering and loading of massive indexes.

Hibernate Envers also looks really interesting. This is a framework for dealing with historical data in Hibernate.

Entities are versioned and all changes (insert, update, delete) are audited transparently. The existing tables are unchanged but new audit tables are created for each entity. For example a Person table will get a Person_AUD table. This looks the same with the addition of revision number and revision type (add, delete, modify) columns.

You can look up by revision and query by revision or entity history. You can also define a RevisionEntity to add new fields atop the standard revision number and date.

It looks really helpful for auditing and dealing with historical data although there is of course a performance hit to inserts, updates and deletes as the audit table must be written to as well.

The first two days are actually the ‘University’ sessions. These are longer, more in depth talks and the first one I went to was the ‘Productive Programmer’ by Neal Ford from Thoughtworks.

This was an interesting talk split into two sections, the first dealing with the mechanics of productivity and the second consisting of a number of tips putting these principals into practice.

The overarching theme was that “any time you are doing simple repetitive stuff on behalf of your computer it is laughing at you”. This means don’t type the same commands over and over but it also means learning keyboard shortcuts for your IDE and OS.

Neal demonstrated the Key Promoter plugin for IntelliJ which will pop up keyboard shortcuts whenever you use a menu item instead. I already use the GOTO class shortcut in IntelliJ all the time but didn’t know you can just type the capital letters of a class and it will find it. For example type ‘mac’ to find MyAwesomeClass.

Neal is so productive he doesn’t even bother to type the left hand side of statements in IntelliJ; he lets the IDE fill that in for him (using introduce variable).

Neal also talked about a concept called ‘locus of attention’ and the need to make your environment quiet to preserve your locus of attention. The higher the level of concentration, the denser the ideas, so turn off notifications, don’t keep email open all the time. Windows is the worst at stealing focus; “it is like a bored 3 year old”. Another reason why 80% of people here seem to have Macs… I quite like the idea of using something like Doodim to gradually dim everything on your desktop apart from the application you are working in.

The problem with using graphical tools to navigate a file system or class structure is that the hierarchies are too deep. Any time you know where you want to get to already it will be faster to search than to navigate. So make use of shortcuts like GOTO class or OSX menu item search.

Another neat idea was to use Selenium to record interactions for debugging web apps. Rather than having to repeatedly click through a sequence to get to where you need to be in the app, simply record the sequence using Selenium and play it back instantly. Even better: get your QA team to record a Selenium script to reproduce a bug and have them attach that to the JIRA ticket instead of a screenshot.

Neal suggests to always use a ‘real’ programming language for scripting (groovy, ruby, php) instead of sed or awk. This allows your little tools to grow into assets and lets you add unit tests and refactor.

The second major session was an introduction to MongoDB by Alvin Richards. This was a pretty in depth session and as he said it was a bit like drinking from the firehose but I came away liking what I saw.

MongoDB belongs to the so-called NoSQL family of data stores and is ‘document oriented’. Documents are stored as binary JSON and the schema is not fixed. This makes it really easy for your schema to evolve with your application.

With MongoDB you get all this built in:

• Horizontal scaling
• Simplified schema evolution
• Simplified deployment and operation

Reads can be scaled using replica sets. These are a cluster of servers where any node can be the primary and failover/recovery is handled automatically. All writes go to the primary node.

Writes can be scaled using automatic sharding. MongoDB’s sharding is transparent to the application code and migrations and rebalancing are handled automatically with no down-time(!)

You can write Map Reduce functions in JavaScript for MongoDB.

You can either use the low-level java library to talk to MongoDB or use Morphia which provides a kind of O/R wrapper to map your POJOs. Morphia gives you Annotations like @Entity, @Transient, @Indexed, @PrePersist, @PreSave, @PostPersist, etc.

To backup MongoDB you can either use mongodump/mongorestore which gives you a binary dump that is not neccesarily consistent from start to finish or use fsync + lock from a slave and then snapshot the files.

It was a long day but a good start to the conference. Tomorrow I’m starting with another NoSQL data store: Cassandra.

In fact it is a Panhard CD from 1964 and it was designed to take on the Ferraris, Cobras and Fords at Le Mans. It was one of the most technically advanced cars ever built, employing aerodynamics that were years ahead of its time. Unfortunately it failed to finish the race. Panhard now makes military vehicles.

This was just one of the fabulous cars I saw at the Goodwood Festival of Speed the other week. It was the first time I had been but if you have even the slightest interest in racing cars I thoroughly recommend it.

I made a little video of some of the pictures I took. If you want to see more, check out the gallery.