I have extensive experience in the design, from scratch, of
complex software. The projects I've worked on have been primarily client
/ sever applications where the client sides have been both rich desktop
applications and web interfaces. I've been involved in the design from
high level architecture down to UI design and refinement through testing
and interaction with testers and real users as well as implementation of
both front and back end code.
I'm most fluent in Java, but have experience with other languages
including PERL and various web 'languages' including PHP, CSS, HTML etc.
Although not languages as such I also have extensive experience with the
various XML related standards including XML Schema. I regard the choice
of language for a project as potentially critical, and would rather
learn a new language than use an inappropriate one.
Within the Java language I have experience with a number of key
frameworks and APIs, detailed below:
- Java Servlets - I introduced Servlet technology (and
the Tomcat application server in particular) into the EBI in 2000, and
have used it extensively in projects since.
- Spring - Since 2007 I have used the Spring framework
for almost all my projects, including writing custom extensions to the
Inversion of Control (IoC) container to allow for on the fly download
of code when initializing bean components.
- Aspect oriented coding - aspects are a powerful
element of Spring's IoC container, I have used them to create
transparent caches and impose easily verifiable security constraints
on server side code.
- Spring-WS - creating and consuming web services with
Spring, through contract-first service definition and integration of
Spring into Tomcat.
- Hibernate - Used to provide back end data services and
accessed through Spring, including dynamic schema generation through
detection of data objects within a set of plugins. This involved
patching and building a customised version of Hibernate.
- Google Web Toolkit - Used to generate rich clients
within the web browser, including integration of GWT-RPC services into
Spring to provide access control and connection to data access layers.
- Web Service Frameworks - Various web service frameworks
including Axis 1 & 2, CXF and Spring-WS,
experience of both contract first and code first design methods.
Experience included inter-operation with arbitrary third party services
through dynamic clients, this required a much more in-depth knowledge
of the web service technology stack than the more typical case where
both service and client are written within the same project, or where
clients are compiled specifically against a particular service.
I am familiar with the full API of both J2SE and J2EE, up to and
including Java 6. In particular I have worked extensively with the
reflection and introspection APIs, including creation of custom
class-loaders and use of reflection to dynamically assemble code on the
fly. I've also used the Swing UI framework to build highly complex MVC
driven user interfaces, often dynamically generated from domain specific
languages or introspection over Java objects.
In addition to the standard Java APIs I've used a large number of
third party libraries - as with most Java programmers one of the first
things I'll do when implementing a piece of software is search to find
whether anyone else has already done so. Other than the APIs used by the
frameworks listed above I don't have a comprehensive list of APIs I've
worked with for the simple reason that adopting a new API is generally
not very much work, so saying that I am familiar with, say, JDOM,
doesn't really tell you anything. I would assume that any decent
programmer would be able to make use of any properly documented third
I have produced a number of APIs intended for third party use as
a deliverable of one of my more recent projects, the Taverna Platform.
This involved packaging and documenting the code in the form of
comprehensive Javadoc, a substantial developer's manual and a set of
Maven archetypes and template projects.
Build tools and environments I've used in past projects. This is
not an exclusive list, but representative of the tool set I would use on
a new project. (My early development work was mostly done in Emacs and
using command line tools to build and verify, these days I prefer to
live within Eclipse).
- Apache Ant & Maven - My earlier projects used the
Ant build system, moving to Maven 2 six years ago. Experience with
Maven in particular includes writing custom plugins and archetypes as
part of a framework project, allowing users of that project to generate
template consumer code with a couple of simple Maven commands.
- Eclipse IDE - I've used Eclipse as my main development
environment since 2003, inluding plugins for Spring, GWT, Maven and
- Version control - CVS and Subversion experience, both
used on projects with around twenty developers with commit access.
- Testing frameworks - Primarily testing with JUnit, but
some experience with continuous integration tools such as Hudson and
CruiseControl (I've used but not configured the latter). Experience
with using code coverage tools to ensure solid test coverage and
general experience with test driven development methods. One of my main
motivations when selecting the Spring framework for past projects was
the ease of testing, although Spring is obviously not a testing tool in
- Others - Experience with the usual selection of project
management tools such as JIRA and other issue trackers, code patching