Our Methodology

We use a combination of proven methodologies and best practices from both industry and the research community to ensure the quality of our work - and that's not just paying lip service. Specifically, we use:

Iterative development

We believe the most successful way to build complex systems is incrementally. We work with our customers to identify minimal 'vertical slices' of functionality that are deep (eg. go from front-end to back-end) but not broad (eg. do not have lots of features). We then build and test each slice and, ideally, deploy it into production before returning to identify the next slice.

This results in regular small releases, keeping our customers engaged at all times and ensuring our software progresses in the right direction.

Test-driven development

We believe the best way to maintain high-quality, reliable software is through automated testing. We write exhaustive automated tests for all our applications, and ensure our code passes all tests before each production release. We even test our tests, using Code Coverage tools.

Defensive programming

Please see our security page.

Reflective practitioner

We believe it is important to consciously reflect 'in action' on our decisions. To deliberately surface any issues and evaluate them in the broader context of our scientific repertoire (eg. design patterns), appreciative system (eg. is it elegant? is it performant?) and overarching theories (eg. Object-Oriented design).

Reflective contracts

We believe the professional-client relationship itself should also be reflective: involving the client closely in the development of the software and keeping them 'in the loop' about technical decisions.

Minimal code

We believe the best way to ensure the correctness of a piece of code is to use it in many different scenarios. We believe in aggressive refactoring and follow the principle of Don't Repeat Yourself to minimize the number of lines of code and maximize how often they are used.

We believe quality is something that is very hard to put back in to a product once it is lost, and continually strive to stay on top of complexity as an application evolves.

Open Source

We believe in building standards-compliant software and using as much Open Source as possible. We believe that open software is good software, and that 'many eyeballs' result in fewer bugs.

Whilst we ourselves are a commercial software company, we give back where we can - we serve on Java Expert Groups, contribute to the Java Development Kit and donate to Open Source projects.

Code quality

We regularly review our code with the results of running tools such as static analysis checkers.

We hate bugs. Whenever we find them, we don't just fix them: first, we write test scripts to ensure they will never slip past again. Then, we fix them and make sure they pass those test scripts. Finally, we analyze how they occurred and consider whether there may be other areas of the application prone to the same problem.