Agile software development consultancy using the Java technology stack.

Expertise in established technologies such as the Spring framework, JPA/Hibernate and REST based web services.

Experience in hip and trendy technologies such as Spring Boot, Docker, AWS and the Cloud.

We love building web applications with a strong design, clean code and robust tests that solves problems.

Observing the solution being used in the wild gives us that warm fuzzy feeling knowing that we built that.

Ian worked for me on a very challenging large scale ETL project which needed flexible and pluggable methods to allow users to create batches of complex data cleansing activities configurable via a complex UI. The team comprised of 3 developers and a QA.

He was instrumental in helping set a clear technical direction within the application, providing guidance and an unswerving drive towards clean, well factored code, making future extensions for further content sets trivial.

Furthermore he’s happy to interface directly with both product owner and external teams as needed and always arrives at a well considered and balanced solution.

Always jovial and positive in his outlook he’s a true asset to any development team and I’m more than happy to recommend him.

Design

A good design means software is easy to change and software will always need changing to incorporate the latest business requirements.

Loose coupling between components allows components to be replaced as changing business requirements demand.

Using design patterns means components are built to well defined standards for common problems thus not reinventing the wheel.

Code

Code should be written for your future self. That is if in six months time you need to modify the code you are about to write you'd want it to be easy to read and understand. It needs to be maintainable.

We strive to write clean, well tested, maintainable code. Code reviews should be a matter of course and we actively engage in them providing detailed feedback to the original developer when required.

final Vehicle myAmazingNewCar =
  new CarBuilder()
    .withMake(Make.ASTON_MARTIN)
    .withModel(Model.VANQUISH)
    .withEngineSize(6.0)
    .withBody(Body.COUPE)
    .withTransmission(Transmission.MANUAL)
    .withFuel(Fuel.PETROL)
    .withColour(Colour.BRITISH_RACING_GREEN)
    .build();
				
@Runner(JUnitRunner.class)
    public class CarBuilderTest {

      @Rule
      public ExpectedException expectedException =
          ExpectedException.none();

      @Test
      public void testSettingEngineSize() {
        final Car car = new CarBuilder()
          .withEngineSize(2.0)
          .build();
        assertThat(car.getEngineSize(), equalTo(2.0));
      }

      public void testSettingNegativeEngineSize() {
        expectedException.expect(CarBuilderException.class);
        expectedException.expectMessage("Invalid engine size");
        new CarBuilder().withEngineSize(-2.0).build();
      }

      public void testSettingZeroEngineSize() {
        expectedException.expect(CarBuilderException.class);
        expectedException.expectMessage("Invalid engine size");
        new CarBuilder().withEngineSize(0).build();
      }

      // etc...
    }
				

Test

During build we strive to write well tested code by fully unit testing each component. We believe that it should take just as long to write unit tests for a component as it did to write the actual component if not longer.

A unit test should not just consist of sunny day scenarios but should also include scenarios that cover the boundaries and failures.

Testing doesn't stop at the unit level. Components should be integration tested to validate that interacting components work as intended. Load and stress testing is also vital to the stability of the application.

When you have a comprehesive testing suite in place you can be confident of making changes without significantly breaking the product. Catching this straight away during development is far better than finding it in production.

Continuous Integration/Delivery

Continuous Integration (CI) is a key aspect of software development. When a developer commits code to the code repository they need fast feedback to be confident that nothing is broken.

We can help you setup your CI solution to verify the quality of the code being committed through automation of testing to code metric reports.

Continuous Delivery (CD) is fast becoming an important aspect of modern day software development. Getting code committed to the code repository and released to production the same day gives real value to your customers and your business.

We can help you setup your CD pipeline to deploy through your development, test, UAT and stage environments right through to production and your end users.

Mentoring

We are happy to support you in developing your staff. Sharing knowledge is very rewarding and a great way to learn yourself. By teaching you learn what you don't know yourself which allows you to fill in gaps in your own knowledge. Whether it's a time saving keyboard shortcut in an IDE or pairing up for a debugging session, we will always strive to help and support other team members without explicit requirement to do so.

Ian is one of the best developers I have met!! He is quiet but very dedicated and extremely knowledgeable particularly with the Java Spring frameworks. He is a good team player whom team leaders all want in their teams because of his ability, code quality and timely work. I'm very pleased to recommend Ian as a person and as a colleague.

Our Work

RS Components

RS Components

JBoss Platform Upgrade

Read more
BlackCat Solutions (for Thomson Reuters)

BlackCat Solutions (for Thomson Reuters)

ETL project for document deduplication

Read more
DeltaRail

DeltaRail

Rail signalling screen design tool

Read more