Vineeth Bhat

1. What’s there?
   1. Why do I write this?
2. Introduction
   1. Standard building blocks
   2. Why the single umbrella of data systems?
   3. How do you describe such systems?
3. Reliability
   1. Fault Tolerant or Fault Resistant?
   2. Do we handle faults or failures?
4. Scalability
   1. Load parameters
   2. Describing Performance
   3. Coping with load
5. Maintainability
6. Takeaways
7. Sources

What’s there?

I’ve started reading DDIA! These are some short notes form Chapter 1.

Why do I write this?

I wanted to create an authoritative document I could refer to for later. Thought that I might as well make it public (build in public, serve society and that sort of stuff).

Also, just reading the textbook will in any case lead to forgetting parts of it. So, thought that I might as well (yay, repetition!) write some short notes for a quick overview later.

Introduction

Standard building blocks

Stuff that pretty much everyone is familiar with –

1. Databases
2. Caches
3. Search indexes
4. Stream processing
5. Batch processing

Why the single umbrella of data systems?

Soo many different things – why do we group them as one?

1. Many tools are optimizes for a variety of different use cases.
   E.g., Redis, a datastore, can also be used as a message queue.
2. Many apps demand multiple requirements that can be encompassed as a single application code.

How do you describe such systems?

Three things –

1. Reliability
2. Maintainability
3. Scalability

Reliability

Fault Tolerant or Fault Resistant?

Resistant. You cannot guarantee that no fault will ever occur.

Do we handle faults or failures?

A fault is one component of a system failing.

A failure is the system going down.

We handle failures.

Scalability

A system’s ability to cope with additional load.

Load parameters

How you describe the load. E.g., the number of writes / reads per second.

Describing Performance

What happens when the load increases?

• Service Level Objectives (SLOs) and Service Level Agreements (SLAs)

• Percentile based measurement

Coping with load

There are just two ways

1. Scaling up (vertical)
2. Scaling out (horizontal)

The best designs are generally a combination of the two.

Maintainability

I think this just revolves around the broader concepts of tech debts, but the major stuff are

1. Operability
2. Simplicity
3. Evolvability

Takeaways

Yeah, this was a very basic introductory chapter that was (kinda?) trivial since I had done distributed systems in school. The main takeaways are:

• Access patterns matter!
• There is no one solution.
• You should always factor in reliability, scalability and maintainability.

Sources

1. Designing Data-Intensive Applications (link)