Earlier the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 7 is all your DEV team should know about Transactions:
The purpose of transactions The concept of transaction: ACID, BASE, single-object and multi-object transactions Weak Isolation Levels: Read Committed, Snapshot Isolation and Repeatable Read.
Earlier the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 6 contains everything the DEV team should consider when designing storage for big data:
Partition aka Shard aka Region aka Tablet aka vNode aka vBucket. It is another approach for storing the data in addition to Replication (reviewed in the previous chapter) How to partition key-value data (primary index).
Earlier the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 5:
Intro. How to scale apps. Replicating and partitioning. Three algos of replicating Single-leader Replication Leaders and Followers Sync and async replication Adding new Followers Handling node outages Technical implementations and all potential problems Multi-Leader Replication Use-cases when it is good Handling write conflicts Three topologies and potential problems Leaderless Replication Writing to the database when a node is down Quorums and problems with them Detecting concurrent writes and how to resolve them Download full mind map (PDF)
Earlier this year the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 4:
What is evolvability. Backward and Forward compatibility Approaches to encode data: JSON, XML, and their binary variants Thrift and Protobuf Apache Avro Models of data flow Through databases Through services: REST, SOAP, RPC and the future Through message brokers - when they are better and when they are not Much more details in the mind-map:
Earlier this year the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 3:
Data structures: Log-structured. SSTables / LSM-trees (when we don’t update anything but write to the end). A very cool idea of how to store data.
Earlier this year the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually I prepared an overview and mind-map.
Chapter 2:
What is data model. Different relations between the data. Relational, Document, Graph data models. Which one is better and when. Schema-on-write, schema-on-read (schemaless). Data locality.
Earlier this year the book club of our company has studied excellent book:
Martin Kleppmann - Designing Data-Intensive Applications
This is the best book I have read about building complex scalable software systems. 💪
As usually (to better learn) I prepared an overview and mind-map.
Chapter 1:
Building blocks of the apps What is Reliability, Scalability and Maintainability. Examples and definitions. Faults and Failures Performance, Load, Latency and Response Time Operability, Simplicity, Evolvability Why you should randomly kill your servers 😅 How Twitter delivers 12,000 tweets per second to 300,000 readers per second.
The book club of our company has chosen a new wonderful book for reading:
Robert Martin - Clean Architecture - a Craftsman’s Guide to Software Structure and Design
Fourth part of the book is about principles of combining components into software systems.
This part is more interesting. It contains:
Overview of components history: Relocatability, Linkers Three principles of Component Cohesion REP: The Reuse/Release Equivalence Principle CCP: The Common Closure Principle CRP: The Common Reuse Principle Three principles of Components Coupling ADP: The Acyclic Dependencies Principle SDP: The Stable Dependencies Principle SAP: The Stable Abstractions Principle I especially enjoyed this chapter because of presented metrics that could be used to measure(!
The book club of our company has chosen a new wonderful book for reading:
Robert Martin - Clean Architecture - a Craftsman’s Guide to Software Structure and Design
👍
Third part of the book is about SOLID principles
Single Responsibility Principle: A module should be responsible to one, and only one, actor. Open-Closed Principle: A software artifact should be open for extension but closed for modification Liskov Substitution Principle: S is a subtype of T if instead of instance of T we can always use an instance of S Interface Segregation Principle: use interfaces to reduce dependency upon changes Dependency Inversion Principle: avoid dependencies on volatile concrete elements I didn’t learn anything new from here (but I am in software engineering for 20+ years already ;).
The book club of our company has chosen a new wonderful book for reading:
Robert Martin - Clean Architecture - a Craftsman’s Guide to Software Structure and Design
👍
The book is superficial so far. Here’s an overview of the second part:
There are three programming paradigms:
Structured programming - is discipline imposed upon direct transfer of control. Object-oriented programming - is discipline imposed upon indirect transfer of control.
