The First Ideal: Locality and Simplicity

Hi,

I once developed a backend with just two engineers. It was the backend for Sunrise Village .

I joined the team already in the pre-production stage, together with my then colleague. For over three years, we were the backend team.

The other teams were larger. We had up to 8 frontend developers, a similar number of artists, two game designers, product owners, product managers, and 2 test automators.

Even the fact that there were only two of us was actually too many. We kept it that way for risk minimization - in case one of us was unavailable.

Why were we so effective?

The reason was that we designed everything with as few dependencies and as simple as possible.

When you checked out the project, there were only two instructions to start the backend in the readme.md:

1. Run `docker-compose up`
2. Start VillageApplication.java

Everything needed to start the backend was preconfigured. All dependencies were started in Docker. Dependencies on internal services were preconfigured with “general purpose” accounts.

And when we made changes to the system, we didn’t need to coordinate with anyone. As long as the API remained compatible, we could release whenever we wanted. Our versioning followed a clear pattern. It wasn’t semantic versioning (for political reasons - but that’s another story), but it was clear when there was a breaking-change.

And the biggest factor: We “stole” the entire business logic from the frontend team. They wrote their code in C# and kept the business logic free from framework dependencies. We took this code and ran an ASP.net service with it.

The backend was simple.

“Locality and Simplicity” is the first ideal of software development that Gene Kim describes in his book The Unicorn Project .

We need to design things so that we have locality in our systems and the organizations that build them. We need simplicity in everything we do. This ideal relates to the degree to which a development team can make local code changes in a single location without impacting various teams. The last place we want complexity is internally, whether it’s in our code, in our organization, or in our processes.

There’s something magical when you achieve this. Everything feels so light.

Where can you reduce complexity? Do it!

Rule the Backend,

~ Marcus