In the first article of this series, I presented the concept of “implementation visibility”. Every requirement can be expressed in source code on a scale of how prominent the implementation will be. There are at least five stages (or levels) on the scale:
- level 0: Inline
- level 0+: Inline with comment
- level 0++: Inline with apologetic comment
- level 1: separate method
- level 2: separate class
- level 2+: new type in domain model
- level 3: separate aggregate
- level 4: separate package or module
- level 5: separate application or service
The article then introduced a simple example and examined how the level 0, 0+ and 0++ would appear within the example code. You may want to read the first article before we carry on with level 1 and 2 in this article.
A quick reminder
Our example is a webshop that lacks brutto prices. The original code of our shopping cart renderer might looked like this:
public class ShowShoppingCart {
public ShoppingCartRenderModel render(Iterable<Product> inCart) {
final ShoppingCartRenderModel result = new ShoppingCartRenderModel();
for (Product each : inCart) {
result.addProductLine(
each.description(),
each.nettoPrice());
}
return result;
}
}
Visibility level 1: Extracted code lives longer
After all the (rather depressing) level 0 implementations of our brutto price calculation, the separated method is the first visibility level to result in code that can be discussed and tested separately:
public class ShowShoppingCart {
public ShoppingCartRenderModel render(Iterable<Product> inCart) {
final ShoppingCartRenderModel result = new ShoppingCartRenderModel();
for (Product each : inCart) {
result.addProductLine(
each.description(),
each.nettoPrice(),
bruttoPriceFor(each));
}
return result;
}
/**
* AN-17: Calculates the brutto price for the given product.
*/
private Euro bruttoPriceFor(Product product) {
final BigDecimal taxFactor = <gets the right tax factor from somewhere>
return product.nettoPrice().multiplyWith(taxFactor);
}
}
The new code is in lines 8 and 13 onwards. The new method was introduced to separate the calculation code from the rendering code. It still lives in the wrong class, but can be tested on its own if you make it public or package accessible. The comment now has a natural scope. And, most important: This implementation is the first where the notion of “brutto price” appears in the JavaDoc and the IDE.
Methods are the smallest parts of our object-oriented code. If you would have one method per requirement, you would just need one extra method of glue code to tie everything together. If one requirement needs to change or becomes obsolete, you know where to cut.
Methods are the primary focus of unit tests. You prepare the parameters for the method you want to test, call it and check the result. This is the AAA or triple-A normal form of unit testing: Arrange, Act, Assert. If several methods or even several objects need to be tested in conjunction, the testing effort rises.
We can conclude that with its own method, the VAT calculation now has its own home. Future readers can grasp the scope of our implementation easily and hopefully make changes under direct test coverage. This is the first visibility level that starts to feel like we meant it.
Visibility level 2: Make it a top-level affair
There is one part in object-oriented code that is even more basic than a method: the class. In Java, each class strives to have its own text file. Before you can write a method in Java, you need to define a class to contain it. Classes are the primary granularity level we navigate our code. Every IDE will show classes as the default elements in our “project explorers”. So what if we introduce a new class for our VAT calculation and move all our code there?
public class ShowShoppingCart {
public ShoppingCartRenderModel render(Iterable<Product> inCart) {
final ShoppingCartRenderModel result = new ShoppingCartRenderModel();
for (Product each : inCart) {
result.addProductLine(
each.description(),
each.nettoPrice(),
CalculateBruttoPrice.forProduct(each));
}
return result;
}
}
/**
* AN-17: Calculates the brutto price with value added tax (VAT) for the given product.
*/
public class CalculateBruttoPrice {
public static Euro forProduct(Product product) {
final BigDecimal taxFactor = <gets the right tax factor from somewhere>
return product.nettoPrice().multiplyWith(taxFactor);
}
}
The new code is in line 8 and the full new class file. This implementation might not look a lot different from level 1 (separate method), but it really is on another level. The brutto price calculation now isn’t tied to rendering shopping carts anymore. It is not tied to anything other than a given product. It is a top-level concept of our application now. Anybody with a product can call the method and receive the brutto price, from anywhere in our application (hopefully respecting our architecture boundaries).
Our unit test class now reads as if we had written it only for the new requirement: CalculateBruttoPriceTest. We still need to invent test products in our test, but the whole notion of render models and shopping carts is gone. In essence, we freed the concept of price calculation from its “evolutionary” ties.
Implementing the new requirement in a separate class, if feasible, adheres to the Single Responsibility Principle (SRP), that requires each class of a system to only have one reason to change. In our case, the CalculateBruttoPrice class only changes if the brutto prices needs adjustment. For all previous visibility levels, that wasn’t true. The ShowShoppingCart class would need modifications if the brutto prices or the shopping cart rendering were to be changed. This improvement is reason enough to elevate our implementation visibility past level 1.
In short, a good heuristics for new requirements (as opposed to change requests for existing requirements) is to start with a new class. If you are unsure, start lower, but keep in mind that classes are the main navigation layer of object-oriented code.
Visibility level 2+: Inviting the requirement to be part of the project’s language
Introducing a new class for our requirement felt good, but something still feels off. When we review the interface of the CalculateBruttoPrice, two things stick out immediately: The class is named as a service (CalculateXYZ as in “do XYZ for me”) and can only calculate brutto prices for products. Our customer was serious with his requirement, so it’s safe to assume that brutto prices will stay in the application and play a key role. We should reflect this seriousness by lifting the implementation visibility level once more and make the BruttoPrice a top level concept of our project’s domain:
public class ShowShoppingCart {
public ShoppingCartRenderModel render(Iterable<Product> inCart) {
final ShoppingCartRenderModel result = new ShoppingCartRenderModel();
for (Product each : inCart) {
result.addProductLine(
each.description(),
each.nettoPrice(),
BruttoPrice.of(each).inEuro());
}
return result;
}
}
The ShowShoppingCart code doesn’t look very different from the level 2 code beforehands. The new code is in line 8, too. The new class isn’t named like a service anymore, but like a concept or domain type. The named constructor of() returns a BruttoPrice instance and not just a Euro object:
/**
* AN-17: Represents the brutto price with value added tax (VAT) for the given Taxable.
*/
public final class BruttoPrice {
public static BruttoPrice of(Taxable item) {
final BigDecimal taxFactor = <gets the right tax factor from somewhere>
return new BruttoPrice(item.nettoPrice().multiplyWith(taxFactor));
}
private final Euro asValue;
private BruttoPrice(Euro value) {
this.asValue = value;
}
public Euro inEuro() {
return this.asValue;
}
}
Now, we can accumulate additional behaviour in the new BruttoPrice type if the need arises. With the service class of level 2, we probably wouldn’t have risen above the Euro abstraction and mixed up netto and brutto prices somewhere in the future. If we model our NettoPrice and BruttoPrice as domain types, the compiler will help us keeping them separate – even if both contain Euros as their value.
With this visibility elevation, we discovered another abstraction: We can create brutto prices for virtually anything that can be taxed. It doesn’t have to be a product, it just needs a netto price and a tax factor. The new (abstract) domain type is named Taxable. Of course, Product is an implementation of Taxable.
This makes us even more independent from any webshop, shopping cart or product. We can now write unit tests for our BruttoPrice without being coupled to the Product class at all. We have successfully decoupled the cart/product part of our application from the prices part. Recognizing and implementing the independence of concepts is an important step towards even higher visibility levels. It is also the groundwork of a low coupled, high cohesive code base where most things fall into their place naturally.
The step from level 2 (separate class) to level 2+ (new domain type) wasn’t just syntactic sugar, it was driven by the insight that separation of concerns is the fundamental principle to achieve maintainability, as long as the abstractions aren’t overwhelming. A good indicator that you’ve taken it too far is when your domain expert (in our example our client) raises her eyebrows in surprise when you talk about your abstract domain types because the names sound outlandish and far-fetched.
But you can take your implementation visibility even further and should really consider doing so given the circumstances. We will learn about visibility level 3 (separate aggregate) in the next blog post of this series. Stay tuned!
Schneide Blog 