Author: David

Stephen Colebourne gave an entertaining talk to a packed room called The Next Big JVM Language. He went over the features of such new JVM languages as Groovy, Clojure, Scala and Fantom (which I’d never heard of).

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.

A couple of pretty heavy-going sessions at Devoxx today. First up was Cassandra by Example with Jonathan Ellis one of the founders of Cassandra support company Riptano.

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.

Today was the first day of Devoxx, the European Java conference held in Antwerp.

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.