Self Study

As you read through the resources below try to answer the following questions:

• In a sentence or two, briefly summarise what we mean by ‘software architecture’?
• Why is a layered architecture useful? Think in particular about complex software systems that are live in production for a long time (and hence technology evolves!), and where maintainability, testability and reliability are important, where changes are constantly being made and where lots of developers in different teams are making changes at the same time
• How do interfaces help to decouple the layers in an application and why is this decoupling useful?
• Can you think of a project you’ve worked on where you used a layered architecture? If so, did it help? If you’ve never used a layered architecture before, can you think of a project that could be improved if refactored to do so?

Resources

• Introduction to software architecture - read sections Introduction to software architecture, Importance of software architecture and Software architecture design (the rest discusses architecture design patterns so feel free to read that too!)
• Good overview of layered architecture - focus on why layered architecture is useful, familiarise yourself with the UI, business logic and database layers, and look at the example application

Exercises

Self Study

As you read through the resources below try to answer the following questions:

• What do we mean by a ‘dependency’ in a Java class?
• What is Inversion of Control (IoC) and how does it relate to Dependency Injection (DI)?
• Can you give an example of IoC that isn’t DI?
• What are some potential issues with Java classes that have dependencies but don’t use DI. Think about testability, maintainability and tight-coupling for large code bases that evolve over time.
• How does DI help solve the above issues?
• What is constructor injection and how is it different to method injection?

Resources

• Overview of dependency injection - ignore section on interface injection
• A more general discussion of Inversion of Control and how Dependency Injection is an example -Note some of the ideas here can be a little hard to understand in the abstract - focusing on the examples can be a good way to see the concepts in action

Exercises

 public static void main(String[] args) {
    Car car = new Car();
    car.start();
  }
 
  static class Car {
    Engine engine = new Engine();
 
    void start() {
      engine.rev();
      System.out.println("Car Started");
    }
 
  }
 
  static class Engine {
    Gears gears = new Gears();
    Cambelt cambelt = new Cambelt();
 
    void rev() {
      gears.initialise();
      cambelt.initialise();
    }
  }
 
 
  static class Gears {
    Set<Cog> cogs = Set.of(new Cog(), new Cog(), new Cog());
 
    void initialise() {
      cogs.forEach(cog -> cog.spin());
 
      // Initialisation logic
    }
  }
 
  static class Cog {
    void spin() {
      // Spin logic
    }
  }
 
 
  static class Cambelt {
    void initialise() {
      // Initialisation logic
    }
  }

Reflections

Think about the following questions, make notes and be prepared to talk through your thoughts in the workshop.

• Suppose we wanted to refactor our car such that it supported multiple different types of engine. How might we do it?
• How would unit testing the Car class be easier after it was refactored to use DI? Remember the unit tests for Car should not need to also test Engine, Gears, Cogs etc
• Why in this example (and in general) do we prefer constructor injection to setter injection?

Self Study

As you read through the resources below try to answer the following questions:

• Where should simple business logic live? e.g. for a Car class with an Engine dependency, in which class should the code to validate that it’s engine must be less than 10 years old live?
• When should standalone service classes be used?
• Should service classes be interfaces or concrete classes? Always? Why? Think about reusability, maintainability, testability.
• What do dependency injection frameworks do and how do they help with dependency injection of services? Note we aren’t going to be using any DI frameworks yet, but it’s good to understand the motivation for them.

Resources

• Overview of service / business logic layer - ignore the non java parts
• Comparison of Service and Database Access Layers (as initially it may seem they are the same)
• Motivation for using DI in the service layer by Guice, a dependency injection framework

Reflections

Think about the following questions, make notes and be prepared to talk through your thoughts in the workshop.

• Did CheckoutService change when switching processors?
• Could you add a new processor without changing CheckoutService?
• Suppose we updated the implementations above to call the real APIs
• What would we need to change if Stripe’s API changes?
• How does having the specific dummy test implementation simplify testing?