It’s all change for me again. I’ve decided to move on from Talis. Today was my last day in the office, and the end of what has been an incredible journey. Although it’s only just over a year since I joined the Talis Platform team, we’ve been constanly iterating and developing innovative solutions. A year ago, we had the opportunity to focus entirely on our next generation data platform, and I felt we had a really productive year. It has certainly been a constant learning-curve for me and forced me to seriously think about the design and implementation of distributed systems. Whether it’s been about dev-ops, continuous deployment, RDF, Jena, sparql, or zeromq, I don’t feel I’ve stopped learning. The pace has been great.

As engineers, I think we all aspire to work on great projects, preferably using cool technology to deliver great software. The last year has certainly allowed me to do that. However, what really counts is being surrounded by great people — and that’s certainly been true of working at Talis. I’ve certainly learnt a lot and have really benefited from working with some truly inspirational people.

In a few weeks time I’ll be joining the team at Black Pepper software. I’m excited about the fresh challenge, but will definitely miss my old colleagues at Talis.

Hi there!

This my first post using Octopress. Today I setup this blog which is currently hosted on github pages. Since I tend to write most of my fragmented thoughts when offline, I’m hoping that having the content in a git repo (that’s editable offline) will be a great help. I also like the fact that I’ll be able to be more in control of my content (when compared to the hosted accounts I’ve used before).

So, fingers-crossed, and here we go! I plan to migrate older posts from other sources to here during the next few weeks)

Over the last few weeks, I’ve been wanting to write a demo for Kasabi to show how to integrate data from a database using object-relational mapping. The idea was that data in an existing database would be polled and loaded in an ETL fashion. However, in order to build a compelling demo, I wanted to generate a simple CRUD over my existing domain classes.

Last weekend I finally got around to reading the Visible Ops handbook. I’d been meaning to read it for a while – ever since I first heard Gene Kim speak at a conference last year.

All in all it’s an interesting read. I didn’t find the book particularly controversial. But, then again, it is nearly 7 years since the book was first published. I think few people would disagree that many of the practices are now part of the ‘received wisdom’ of operations. I also found it useful to get a reminder of the ITIL jargon. Using the correct terms for this sort of thing is something I’m a bit weak on, but as the authors say in the book, having a common language is vital.

Over the last couple of days I’ve been trying to pull together a demo of integrating an existing JPA application with Kasabi. It’s been a fun journey learning (and relearning) the JPA spec, and also working with some of the internals of the Hibernate framework. It’s interesting that when a framework becomes really ubiquitous – like Hibernate, in this case – it’s really easy to find online docs and howtos about how to use it, but it’s far harder to sift through all that noise to find docs that help you extend it.

In the end, I did get it working: I re-used the annotation scanning plumbing that Hibernate provides to get access to the JPA configuration, then I walked the object graph marshalling entities as RDF (I used NTriples) before submitting them to a Kasabi dataset.

Of course, to complete the demo, I needed an actual JPA application, so I’ve had some fun re-learning Spring Roo and Grails in order to build a quick database-backed webapp. Normally I dislike scaffolding-based frameworks, but they’re certainly useful for creating a quick functional app.

I’ll submit a link to the code at some point soon.

It’s nice to see Ways of Thinking, Ways of Seeing (ed. Bissell & Dillon) finally published [1]. I contributed Chapter 5 (see [2]), entitled ‘Early Computational Modelling: Physical Models, Electrical Analogies and Analogue Computers’. The origins of this book came from a session which Chris Bissell organised at SHOT 2007. It’s taken a while to find it’s way into print, but I think it’s an interesting collection of different perspectives on modelling.

Thanks to Chris Bissell and Chris Dillon for making it all happen!

[1] http://www.springer.com/engineering/robotics/book/978-3-642-25208-2

[2] http://www.springerlink.com/content/r071882m26486028/

At Talis we’ve been building our RDF platform following a distributed SOA architecture. Most of our integrations are through RESTful HTTP APIs, and in our Java projects we tend to use Apache HttpClient to consume them.

As a result, when writing tests I find myself having to frequently stub-out a remote service. Sometimes we do the usual thing and create mocks. This is fairly easy, but does involve quite a lot of plumbing – you need a mock HttpClient, then a mock GetRequest, then a mock entity, and so on… it can certainly create quite a lot of boilerplate.

On 23rd September, a colleague and I attended the PubSub Huddle in London. It was a one-day conference/hack-afternoon hosted by SkillsMatter.

The day was a good event, there were quite a few people around in the morning and I had some particularly interesting conversations with people responsible for messaging software in hedge funds and banks. The basic structure of the day was talks in the morning which was then followed by a self-organised ‘hack-afternoon’. The morning was excellent and had a large number of attendees. The afternoon was also good fun, but things did tail off as people started disappearing.