Skip to content
BENIBIX Learn

Architecture

How systems fit together · 59 terms

Sort
Compare

Architecture Basics

15

The big-picture shape of a system, and the ideas used to judge whether its parts are well split.

The big shape of a system. It shows the main parts and how they link.

Giving each part of a program one job. Each part is kept apart from the rest.

How much one part of a program leans on another.

How well the code in one part fits together.

Hides the hard parts of a system. You use a few simple commands.

Planning the parts of a big app, and how they work as one.

A service that keeps nothing between calls. So any copy can answer.

A service that keeps data between calls. So the right copy must answer.

Teams and Architecture

2

How the way teams are set up shapes the system they build, and how to use that on purpose.

A system's parts copy the teams that built it. They join where the teams talk.

Shaping your teams on purpose to get the system shape you want.

Architecture Documents

5

Writing a design down: the plan before the code, the record of each big choice, and the standard drawings.

A written plan for a new part of an app. The team reads it before coding.

A short note that saves one design choice and why the team made it.

A set of standard drawings. They show how code is built and how it acts.

A diagram of the messages between parts of a system. Read it from top to bottom.

Four zoom levels for drawing software. Start with the big map and end at the code.

Architecture Styles

13

The common shapes a whole system can take, from one deployable app to many small services.

An app built and shipped as one single unit, with all its parts in it.

One app shipped as a unit, but split inside into strict parts.

Building an app as many small services. Each one is shipped on its own.

A system split in two: clients that ask and servers that answer.

Parts of a system talk by sending out events. Other parts react to them.

Computers that share work and data with each other. There is no main server.

One app that serves many customers. Each one's data is kept apart.

Application Structure

6

Ways to arrange the code inside one application so the rules stay apart from the tools.

An app split into stacked layers. Each one calls only the one below.

Splits an app in three: data, screens and the code that links them.

The rules of the business sit in the middle. Tools stay at the edge.

Keeping an app's core apart. It links to the outside through ports and adapters.

Code that uses the same words as the business it serves.

A way to split screen code into three parts. Data, the view, and a view model.

Design Patterns

11

Named, reusable shapes for problems that keep coming up when writing classes and objects.

A known way to solve a problem that keeps coming up in code.

Only one object of a class may exist. Every part shares it.

One function or class makes the objects. The callers need not know how.

One object keeps a list of others. It tells them all when it changes.

A wrapper that lets one piece of code fit another.

Pick how a job is done while the program runs.

An object wrapped in another that adds a feature. It still looks the same.

Making a big object one step at a time. At the end you call build.

One simple front for many parts. Callers need just one call.

One class that hides how a kind of data is read and saved.

Code gets the parts it needs from outside. It does not make them itself.

Events and Messages

7

How the parts of a system pass work and news to each other without calling each other directly.

A line where messages wait for a free worker.

Send a message to a topic. All who listen get a copy.

A shared line that takes events from senders to whoever wants them.

Save each change as an event. Build the present state from them.

Splitting the code that changes data from the code that reads it.

Split a task across services into steps. Each step has its own undo.

Work an app hands off to run later, so the user does not have to wait.

Scaling

3

Coping with more users and more work, by adding machines or making them bigger.

How well a system copes as users or jobs grow.

Handling more work by adding more machines that share the load.

Make one machine bigger to handle more work.

Distributed Systems

10

Many machines working as one system, and the parts that route and guard the traffic between them.

Many computers that work as one. They talk over a network.

When a network splits, a system must give up one of two things.

Copies of data may differ for a moment. Then they all match.

One front door that sends each request to the right service.

Small helpers sit next to each service. They handle the calls between them.

Each read shows the last write. It does not matter which copy answers.

Resilience

4

Keeping a system running when one of its parts is slow or broken.

One part whose failure stops the whole system.

Stop calling a failing service for a while. Then trouble does not spread.

Try a failed call again. Wait longer before each new try.

The longest a program will wait for a reply. Then it gives up.