Table of Contents

• Road Map

• Computer Science

  1. Operating System
  2. Computer Architecture
  3. Compilation
  4. Network
  5. Data Structure
  6. Database

• Programming Language

  • C/C++

• Software Engineering

  1. Coding Cultivation
  2. Code Review
  3. Safety Precaution
  4. Testing
  5. Publishing

• System Design

• Linux

  1. Kernel
  2. Memory Management
  3. Linux Network
  4. AIO
  5. Lock-free
  6. Memory Order
  7. CPU Cache

• Distributed Architecture

  1. Distributed Messages System
  2. Logs & Data
  3. Distributed monitoring and tracking
  4. Data Analysis
  5. Distributed Architecture Engineering Design
  6. Design Pattern
  7. Failure testing of distributed systems
  8. Scalability
  9. Consistent Hashing
  10. Cache
  11. Message Queue
  12. Log
  13. Performance
  14. Search
  15. Architecture Practices by Companies

• Microservice

  1. API Gatway
  2. Microservice VS SOA, IaaS, Paas, Monolithic
  3. Practice
  4. Authentication & Authorization
  5. Design Pattern

• Cloud Native

• Cloud Computing

  1. IO Virtualization

• Thanks

Computer Science

• Teach Yourself Computer Science

Operating System

• 📙 Computer Systems A Programmer’s Perspective ✏️ Book Notes

• 📙 Modern Operating Systems ✏️ Book Notes

• 📙 Operating Systems: Three Easy Pieces

• 📙 Operating System Concepts

• 📙 Operating Systems Design and Implementation

• 📙 Advanced Programming in the UNIX Environment

• CPU Registers x86_32

• CPU Registers x86_64

Computer Architecture

• 📙 Computer Organization and Design: The Hardware/Sofeware Interface ✏️ Book Notes
• 📙 Computer Architecture: A Quantitative Approach
• 📙 Structure and Interpretation of Computer Programs

Compilation

• 📙 Compilers: Principles, Techniques, and Tools
• 📙 Programmer Self-Cultivation: Linking, Loading and Libraries (🇨🇳 CN) ✏️ Book Notes

Network

• 📙 TCP/IP ILLustrated Volume 1: The Protocols ✏️ Book Notes

• 📙 UNIX Network Programming, Volume 1: The Sockets Networking API ✏️ Book Notes: UNP ✏️ Book Notes: Linux Programming

• 📙 UNIX Network Programming, Volume 2: Interprocess Communications

• 📙 Linux System Programming

• 📙 Computer Networking: A Top-Down Approach

• 📙 Computer Networks, 5th Edition

• 📙 Practical Packet Analysis: Using Wireshark to Solve Real-World Network Problems, 2nd Edition

• Internet protocol suite (wikipedia)

• Let’s Code a TCP/IP Stack, 1: Ethernet & ARP

• Let’s Code a TCP/IP Stack, 2: IPV4 & ICMPv4

• Let’s Code a TCP/IP Stack, 3: TCP Basics & Handshake

• Let’s Code a TCP/IP Stack, 4: Tcp Data Flow & Socket API

• Let’s Code a TCP/IP Stack, 5: TCP Retransaction

• C10k Problem

• C10m Problem

• The Secret To 10 Million Concurrent Connections - The Kernel Is The Problem, Not The Solution

• Congestion Avoidance and Control.pdf

• Nginx HTTP/2

• Coping with the TCP TIME-WAIT state on busy Linux servers

• HTTP

  • RFC 7230 - Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing
  • RFC 7231 - Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content
  • RFC 7232 - Hypertext Transfer Protocol (HTTP/1.1): Conditional Requests
  • RFC 7233 - Hypertext Transfer Protocol (HTTP/1.1): Range Requests
  • RFC 7234 - Hypertext Transfer Protocol (HTTP/1.1): Caching
  • RFC 7235 - Hypertext Transfer Protocol (HTTP/1.1): Authentication
  • RFC 7540 - Hypertext Transfer Protocol Version 2 (HTTP/2)
  • RFC 7541 - HPACK: Header Compression for HTTP/2

• TLS

  • RFC 8446 - The Transport Layer Security (TLS) Protocol Version 1.3
  • RFC 8449 - Record Size Limit Extension for TLS

• QUIC

  • RFC 9000 - QUIC: A UDP-Based Multiplexed and Secure Transport

• ARP

  • RFC 826 - An Ethernet Address Resolution Protocol

• ICMP

  • RFC 792 - Inernet Control Message protocol

• TCP

  • RFC 793 - Transmission Control Protocol
  • RFC 813 - Window and Acknowledgement Strategy in TCP
  • RFC 879 - The TCP Maximum Segment Size and Related Topics
  • RFC 896 - Congestion Control in IP/TCP Internetworks
  • RFC 2581 - TCP Congestion Control
    • RFC 5681 - TCP Congestion Control
    • RFC 6582 - The NewReno Modification to TCP’s Fast Recovery Algorithm
  • RFC 2018 - TCP Selective Acknowledgment Options
    • RFC 2883 - An Extension to the Selective Acknowledgement (SACK) Option for TCP
  • RFC 2988 - Computing TCP’s Retransmission Timer
  • RFC 6298 - Computing TCP’s Retransmission Timer

• UDP

  • RFC 768 User Datagram Protocol

• IP

  • RFC 791 - Internet Protocol

• VXLAN

  • RFC 7348 - Virtual eXtensible Local Area Network

• Generic Routing Encapsulation

  • RFC 2784 - Generic Routing Encapsulation (GRE)
  • RFC 2890 - Key and Sequence Number Extensions to GRE
  • RFC 8086 - GRE-in-UDP Encapsulation

• Tunnel

  • RFC 1853 - IP in IP Tunneling
  • RFC 2784 - Generic Routing Encapsulation (GRE)
  • RFC 2661 - Layer Two Tunneling Protocol "L2TP"
  • RFC 2637 - Point-to-Point Tunneling Protocol (PPTP)

• Other

  • STUN Traceroute
  • Implementing Remote Procedure Calls

Database

• 📙 Database System Concepts (Fifth Edition)
• 📙 High Performance MySQL, 3rd
• 📙 Inside MySAQL: InnoDB Storage Engine
• 📙 Relational Database Index Design and the Optimizers
• MySQL Internals Manual
• How to Analyze and Tune MySQL Queries for Better Performance
• MySQL Performance Tuning 101
• MySQL Performance Schema & Sys Schema
• MySQL Performance: Demystified Tuning & Best Practices
• MySQL Security Best Practices
• MySQL Cluster Deployment Best Practices
• MySQL High Availability with InnoDB Cluster

Data Structure

• 📙 Data Structures and Algorithm Analysis in C: Second Edition

Algorithm

• 📙 Algorithms，Fouth Edition
• 📙 Grokking Algorithms: An illustrated guide for programmers and other curious people
• 📙 Programming Pearls (2/e)
• 📙 Data Structures and Algorithm Analysis in C: Second Edition

Programming Language

The Essence of Programming

• Niklaus Emil Wirth: Algorithms + Data Structures = Programs .pdf
• Robert Kowalski: Algorithm = Logic + Control .pdf

C/C++

• ISO/IEC C++ Standards

• coolshell 🇨🇳

  • How to lear C language well
  • Deep understanding of C language
  • C language puzzle
  • Is C language easy?
  • The overflow of integer
  • Pointers and array member of structure

Open-Close

• C++ Cheat Sheets & Infographics

• 📙 The C Programming Language

• 📙 C Programming: A Modern Approach

• 📙 C Traps and Pitfalls

• 📙 C++ Primer, 5th Edition ✏️ Book Notes

• 📙 Effective C++ ✏️ Book Notes

• 📙 More Effective C++ ✏️ Book Notes

• 📙 Modern Effective C++ ✏️ Book Notes

• 📙 Inside C++ Object Model ✏️ Book Notes

• 📙 C++ Templates The Complete Guide ✏️ Book Notes

• 📙 Modern C++ Design ✏️ Book Notes

• Agner Fog: Optimizing Software in C++.pdf

• Software optimization resources

• C++ FAQ

• How C++ Resolves a Function Call

• C Language Function Call Stack 🔗 Part 1 🔗 Part 2 🔗 Part 3

• How to Use C++ for Cross-Platform Development

• trivial_abi

• Paramter Passing in C and C++

• Pass-by-value vs Pass-by-reference

• Type Erasure

• Lambdas: From C++11 to C++20 🔗 Part 1 🔗 Part 2

• Eli Bendersky: How debuggers work 🔗 Part 1 🔗 Part 2 🔗 Part 3

• What Every C Programmer Should Know About Undefined Behavior 🔗 Part 1 🔗 Part 2 🔗 Part 3

• GNU Compiler Collection (GCC) Internals

• Linux x86 Program Start Up or How do we get to main?

• OOP

  • Itanium C++ ABI (Revision: 1.75)
  • VTable Beginner 1: Interview Series C++ object layout 🇺🇸 EN 🇨🇳 CN
  • VTable Beginner 2: Understand C++ vtable from assembly code 🔗 Part 1
  • VTable Expert 1: What does C++ Object Layout Look Like?
  • VTable Expert 2: C++ Virtual Table Tables(VTT)
  • coolshell: C++ virtual function table analysis (:cn: CN)
  • Inheritance Without Pointers
  • Runtime Polymorphism Without Objects or Virtual Functions
  • The cost of dynamic (virtual calls) vs. static (CRTP) dispatch in C++
  • The Sad True about C++ Copy Elision

• Const & Mutable

  • Const Correctness
  • Mutable
  • How to Share Code with Const and Non-Const Functions in C++

• STL

  • Creating STL Containers in Shared Memory

• C++ Memory Model

  • Memory layout of C ++ objects (:cn: CN)
  • C++ objects Memory layout (:cn: CN)
  • std::memory_order
  • C++ Memory Model
  • Sequential Consistency
  • The Atomic Flag
  • The Atomic Boolean
  • Atomics
  • Synchronization and Ordering Constraints
  • Sequential Consistency applied
  • Acquire-Release Semantic
  • Transitivity of the Acquire-Release Semantic
  • memory_order_consume
  • Acquire-Release Semantic - The typical Misunderstanding
  • Fences are Memory Barriers
  • Acquire-Release Fences
  • Relaxed Semantic
  • shared_ptr Thread Safety

• CRTP

  • Curiously Recurring Template Pattern (CRTP)
  • The CRTP, episode One: Definition
  • The CRTP, episode Two: What the CRTP can bring to your code
  • The CRTP, episode Three: An implementation helper for the CRTP
  • Mixin Classes: The Yang of the CRTP
  • How to Turn a Hierarchy of Virtual Methods into a CRTP
  • Replacing CRTP Static Polymorphism With Concepts
  • Removing Duplicates in C++ CRTP Base Classes
  • How to Reduce the Code Bloat of a Variadic CRTP
  • Variadic CRTP Packs: From Opt-in Skills to Opt-in Skillsets
  • Variadic CRTP: An Opt-in for Class Features, at Compile Time

• Template

  • One Trick with Private Names and Function Templates
  • Modern C++ Features – Class Template Argument Deduction
  • Build Throughput Series: Template Metaprogramming Fundamentals
  • Build Throughput Series: More Efficient Template Metaprogramming
  • How to Pass a Variadic Pack as a First Argument of a Function
  • Dependent Name: Inheritance and Member Functions of Class Templates
  • CppCon 2019: Jorg Brown "Reducing Template Compilation Overhead, Using C++11, 14, 17, and 20."

• C++11

  • Herb Sutter: Move Simply
  • C++ Move Semantics - The Complete Guide
  • Andreas: Can I touch a moved-from object
  • Scott Meyers: Universal References in C++11
  • C++ Proposal - Forwarding References

• C++17

  • Table: C++17 Features.pdf
  • How std::any Works
  • Everything You Need to Know About std::variant from C++17
  • Runtime Polymorphism with std::variant and std::visit
  • Visiting a std::variant with the Overload Pattern
  • Simplify code with ‘if constexpr’ in C++17
  • Pass string_view by value

• C++ 20

  • Table: C++20 Features.pdf

  • All C++20 core language features with examples

  • C++20: Aggregate, POD, trivial type, standard layout class, what is what

  • Notes on C++ SFINAE, Modern C++ and C++20 Concepts

  • std::index_sequence and its Improvement in C++20

  • constexpr vector and string in C++20 and One Big Limitation

  • Raymond Chen: C++ coroutines

    • A map through the three major coroutine series
    Open/Close

    • Awaitable Objects

      • Getting started with awaitable objects
        • Constructible awaitable or function returning awaitable?
        • Framework interop
        • Awaiting an IAsyncAction without preserving thread context
      • Short-circuiting suspension, part 1
      • Short-circuiting suspension, part 2
        • no callable ‘await_resume’ function found for type
      • Defining the co_await operator
        • The co_await operator and the function search algorithm
        • The problem of the synchronous apartment-changing callback
        • The problem of the DispatcherQueue task that runs too soon, part1 🔗 Part 2 🔗 Part 3 🔗 Part 4

    • Awaitable Signals

      • Creating a co_await awaitable signal that can be awaited multiple times
        • 🔗 part 1 🔗 part 2 🔗 part 3 🔗 part 4 🔗 part 5
        • 🔗 part 6
          • Creating other types of synchronization objects that can be used with co_await
            • 1: The one-shot event
            • 2: The basic library
            • 3: Parallel resumption
            • 4: The manual-reset event
            • 5: The auto-reset event
            • 6: The semaphore
            • 7: The mutex and recursive
            • 8: The shared mutex
            • 9: The shared mutex (continued)
            • 10: Wait for an event to clear
      • Creating a task completion source for a C++ coroutine
        • Producing a result
        • Producing a result with references
        • Producing nothing
        • Failing to produce a result

    • Coroutine Promises

      • The mental model for coroutine promises
      • Basic implementation of a promise type
      • The initial and final suspend, and improving our return_value method
        • What happens if an exception occurs in my return_value?
      • Making the promise itself be the shared state, the inspiration
      • Making the promise itself be the shared state, the outline
      • Building a result holder for movable types
      • Accepting types via return_void and return_value
      • Awaiting the simple_task
      • Managing the reference count of the coroutine state
        • The lifetime of objects involved in the coroutine function
        • Tradeoffs of making the promise be the shared state
      • Making it impossible to co_await a task twice
      • Getting rid of our mutex
      • Getting rid of our reference count
        • Allowing the awaiter to be destroyed while suspended
        • Getting rid of our atomic variant discriminator
        • Cold-start coroutines
        • Improving cold-start coroutines which complete synchronously
        • Associating multiple task types with the same promise type
      • What does it mean when I declare my coroutine as noexcept?
      • How do I create a coroutine that terminates on an unhandled exception?
      • Snooping in on the coroutine body
      • Adding custom resume context support to our awaiter
        • Waiting synchronously for our coroutine to complete
        • Converting among tasks that use the same promise
      • Promise constructors

    • Mix

      • Why is coroutine_handle::resume() potentially-throwing?
      • A subtle way your await_suspend can access the coroutine frame when it shouldn’t

  • Asymmetric Transfer: C++ coroutines

    • Coroutine Theory
    • Understanding operator co_await
    • Understanding the promise type
    • Understanding Symmetric Transfer

  • constexpr Dynamic Memory Allocation, C++20

  • C++20 Dynamic Allocations at Compile-time

  • Ordering asynchronous updates with coroutines

    • 🔗 Part 1: Mutual exclusion
    • 🔗 Part 2: Restart with hand-off
    • 🔗 Part 3: Let them all compete, but only one wins
    • 🔗 Part 4: Bowing out, explicit version
    • 🔗 Part 5: Bowing out via cancellation

Software Engineering

• The key to Accelerating Your Coding Skills
• Character Encoding
• What are some of the most basic things every programmer should know?
• 97 things every programmer should know?
• How to Ask Question The Smart Way

Coding Cultivation

• 📙 Refactoring: Improving the Design of Existing Code ✏️ Book Notes

• 📙 Working Effectively with Legacy Code

• 📙 Clean Code: A Handbook of Agile Software Craftsmanship ✏️ Book Notes

• 📙 The Clean Coder：A Code of Conduct for Professional Programmers

• https://refactoring.guru

Code Review

• Code Review Best Practices
• How Google Does Code Review

Safety Precaution

• https://www.owasp.org/index.php/Main_Page
• Secure Coding Practice Guidelines
• SEI SERT Coding Standards
• Hardening Your HTTP Security Headers

Testing

• 📙 Perfect Software: And Other Illusions about Testing
• 📙 How Google Tests Software

Publishing

• Checklist

System Design

• 📙 Domain-Driven Design: Tackling Complexity in the Heart of Software

• 📙 The Art of UNIX Programming

• 📙 Clean Architecture

• donnemartin/system-design-primer

• Grokking System Design ✏️ Book Notes

• Grokking Advanced System Design ✏️ Book Notes

• Grokking the Object Oriented Design ✏️ Book Notes

• Six Programming Paradigm

• Programming Paradigms for Dummies.pdf

• Stanford Programming Paradigm

• The Twelve-Factor App

  • 

• Avoid Over Engineering

• Best Practices for Designing a Pragmatic RESTful API

• HTTP API Desgin

• API Guildlines

• The Problem With Logging

• The Onion Architecture 🔗 Part 1 🔗 Part 2 🔗 Part 3 🔗 Part 4

• Wikipedia - Programming paradigm

• Wikipedia - Software design pattern

Linux

• Red Hat Enterprise Linux
• x86-TSO: A Rigorous and Usable Programmer’s Model for x86 Multiprocessors
• Spurious wakeup 🔗 C++ Condition Variable
• LWN.netNews Kernel Index

Kernel

• ✏️ Linux Kernel 4.19
• ✏️ Understanding Linux Kernel
• ✏️ Linux Kernel Development
• What is RCU? – "Read, Copy, Update"
• Linux Insides
• LWN’s kernel page
• Learn Linux Kernel from Android Perspective
• Linux Kernel Doc
• Kernel Planet: Kernel Developers Doc
• Linux Performance and Tuning Guidelines.pdf
• Linux Performance
• Optimizing web servers for high throughput and low latency

Memory Management

• What Every Programmer Should Know About Memory.pdf
• Memory Barriers: a Hardware View for Software Hackers.pdf
• A Tutorial Introduction to the ARM and POWER Relaxed Memory Models.pdf
• Understanding glibc malloc
• ptmalloc
• tcmalloc 🔗 Ref 🔗 Ref
• jemalloc.pdf
• C dynamic memory allocation
• Research on ptmalloc, tcmalloc and jemalloc memory allocation strategies (:cn: CN)
• Memory optimization summary: ptmalloc, tcmalloc, and jemalloc
• Scalable memory allocation using jemalloc
• Linux Kernel Vs. Memory Fragmentation Part I

Linux Network

• 📙 Linux High Performance Server Programming (:cn: CN) ✏️ Linux Programmnig Noetes ✏️ Linux System Notes

• 📙 Network tuning

• Linux Advanced Routing & Traffic Control HOWTO

• Red Hat Enterprise Linux Network Performance Tuning Guide.pdf

• Awesome Pcap Tools

• Making Linux TCP Fast.pdf

• Monitoring and Tuning the Linux Networking Stack: Receiving Data

• Monitoring and Tuning the Linux Networking Stack: Sending Data

• The BSD Packet Filter: A New Architecture for User-level Packet Capture.pdf

AIO

• Boost application performance using asynchronous I/O
• Lazy Asynchronous I/O For Event-Driven Servers
• IOCP
• Reactor: An Object Behavioral Pattern for Demultiplexing and Dispatching Handles for Synchronous Events.pdf
• Understanding Reactor Pattern: Thread-Based and Event-Driven
• The Design and Implementation of the Reactor.pdf
• The Secret To 10 Million Concurrent Connections -The Kernel Is The Problem, Not The Solution
• Epoll is fundamentally broken 🔗 1 🔗 2
• The implementation of epoll 🔗 1 🔗 2 🔗 3 🔗 4

Lock-free

• An Introduction to Lock-Free Programming
• Lock-Free Data Structures
• Lock-Free Data Structures.pdf
• Is Parallel Programming Hard, And, If So, What Can You Do About It?
• Non-blocking Algorithm
• Read Copy Update
• Seqlock
• Implementing Lock-Free Queues
• Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms.pdf
• Implementing a Recursive Mutex

Memory Order

• Weak vs. Strong Memory Models
• This Is Why They Call It a Weakly-Ordered CPU
• Memory Barriers Are Like Source Control Operations
• Acquire and Release Semantics
• Memory Ordering at Compile Time
• The Happens-Before Relation
• The Synchronizes-With Relation
• Acquire and Release Fences Don't Work the Way You'd Expect
• Acquire and Release Fences
• Roll Your Own Lightweight Mutex
• Can Reordering of Release/Acquire Operations Introduce Deadlock?
• You Can Do Any Kind of Atomic Read-Modify-Write Operation
• The Purpose of memory_order_consume in C++11
• Atomic vs. Non-Atomic Operations
• Memory Reordering Caught in the Act

CPU Cache

• Gallery of Processor Cache Effects TODO:?
• coolshell: CPU Cache
• L1 cache lines
• Scott Meyers: CPU Caches and Why You Care PPT
• Cache Architecture and Design
• Nonblocking Algorithms and Scalable Multicore Programming
• Optimizing for instruction caches Part 1 Part 2 Part 3
• Latency Numbers Every Programmer Should Know
• arm64 cache 🇨🇳

Distributed Architecture

• Distributed Systems Reading Group

• 📙 Distributed Systems, 3rd Edition

• 📙 Distributed Systems for fun and profit

• 📙 Designing Data Intensive Applications

• 📙 Distributed Systems: Principles and Paradigms.pdf

• 📙 Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services ✏️ Book Notes

• 📙 Principles of Distributed Systems.pdf

• 📰 Transaction Across DataCenter 📺 YouTuBe

• Scalable Web Architecture and Distributed Systems

• Scalability, Availability & Stability Patterns

• System Design Primer

• An introduction to distributed systems

• Byzantine fault PDF

• The Byzantine Generals Problem

• Practical Byzantine Fault Tolerance.pdf

• CAP Theorem

• A Brief Tour of FLP Impossibility

• DLS.pdf

• Introduction to Distributed System Priciples (:cn: CN)

• CAP Twelve Years Later: How the "Rules" Have Changed

• Harvest, yield, and scalable tolerant systems

• Base: An Acid Alternative

• Eventually Consistent

Distributed Messages System

• Kafka: a Distributed Messaging System for Log Processing.pdf
• Wormhole: Reliable Pub-Sub to Support Geo-replicated Internet Services.pdf
• board the Databus! LinkedIn's Scalable Consistent Change Data Capture Platform

Logs & Data

• The Log: What every software engineer should know about real-time data's unifying abstraction
• The Log-Structured Merge-Tree (LSM-Tree).pdf
• Immutability Changes Everything.pdf Video
• Tango: Distributed Data Structures over a Shared Log.pdf

Distributed monitoring and tracking

• Dapper, a Large-Scale Distributed Systems Tracing Infrastructure.pdf

Data Analysis

• The Unified Logging Infrastructure for Data Analytics at Twitter.pdf

• Scaling Big Data Mining Infrastructure: The Twitter Experience.pdf

• Dremel: Interactive Analysis of Web-Scale Datasets.pdfd

• Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing.pdf

• Distributed Programming Model.pdf

• PSYNC: A partially synchronous language for fault-tolerant distributed algorithms.pdf

• Logic and Lattices for Distributed Programming.pdf

• Services Engineering Reading List

• Readings in distributed systems

• Google Research - Distributed Systems and Parallel Computing

Distributed Architecture Engineering Design

• Designs, Lessons and Advice from Building Large Distributed Systems.pdf
• Building Software Systems At Google and Lessons Learned
• The Twelve-Factor App
• Notes on Distributed Systems for Young Bloods
• On Designing and Deploying Internet-Scale Services
• 4 Things to Keep in Mind When Building a Platform for the Enterprise
• Principles of Chaos Engineering
• Building Fast & Resilient Web Applications
• Designing For Resiliency Will Be So 2013
• Ten design principles for Azure applications
• Eventually Consistent
• Writing Code that Scales
• Automate and Abstract: Lessons from Facebook on Engineering for Scale

Design Pattern

• Martin Fowler: Patterns of Distributed Systems

  Open/Close

  • Clock-Bound Wait
  • Consistent Core
  • Emergent Leader
  • Fixed Partitions
  • Follower Reads
  • Generation Clock
  • Gossip Dissemination
  • Heart Beat
  • High-Water Mark
  • Hybrid Clock
  • Idempotent Receiver
  • Key-Range Partitions
  • Lamport Clock
  • Leader Follwers
  • Lease
  • Low-Water Mark
  • Paxos
  • Quorum
  • Replicated Log
  • Request Batch
  • Request Pipeline
  • Request Waiting List
  • Segemented Log
  • Single Scoket Channel
  • Singular Update Queue
  • State Watch
  • Two Phase Commit
  • Version Vector
  • Versioned Value
  • Write-Ahead Log

• MicroSoft Cloud Design Patterns

  Open/Close

  • Design and implementation

    • Ambassador
    • Anti-corruption Layer
    • Backends for Frontends
    • Command and Query Responsibility Segregation (CQRS)
    • Compute Resource Consolidation
    • External Configuration Store
    • Gateway Aggregation
    • Gateway Offloading
    • Gateway Routing
    • Leader Election
    • Pipes and Filters
    • Sidecar
    • Static Content Hosting
    • Strangler Fig

  • Management and monitoring

    • Ambassador
    • Anti-corruption Layer
    • External Configuration Store
    • Gateway Aggregation
    • Gateway Offloading
    • Gateway Routing
    • Health Endpoint Monitoring
    • Sidecar
    • Strangler Fig

  • Messaging

    • Anti-corruption Layer
    • Claim Check
    • Choreography
    • Competing Consumers
    • Pipes and Filters
    • Priority Queue
    • Publisher/Subscriber
    • Queue-Based Load Leveling
    • Scheduler Agent Supervisor
    • Sequential Convoy
    • Asynchronous Request-Reply

  • Data management

    • Cache-Aside
    • Command and Query Responsibility Segregation (CQRS)
    • Event Sourcing
    • Index Table
    • Materialized View
    • Sharding
    • Static Content Hosting
    • Valet Key
    • Saga

  • Performance and scalability

    • Cache-Aside
    • Choreography
    • Command and Query Responsibility Segregation (CQRS)
    • Event Sourcing
    • Deployment Stamps
    • Geodes
    • Index Table
    • Materialized View
    • Priority Queue
    • Queue-Based Load Leveling
    • Sharding
    • Static Content Hosting
    • Throttling

  • Availability

    • Deployment Stamps
    • Geodes
    • Health Endpoint Monitoring
    • Queue-Based Load Leveling
    • Throttling

  • Resiliency

    • Bulkhead
    • Circuit Breaker
    • Compensating Transaction
    • Health Endpoint Monitoring
    • Leader Election
    • Queue-Based Load Leveling
    • Retry
    • Scheduler Agent Supervisor

  • Security

    • Federated Identity
    • Gatekeeper
    • Valet Key

• AWS Cloud Pattern

• Google: Design patterns for container-based distributed systems.pdf

• A pattern language for microservices

• SOA Patterns

Failure testing of distributed systems

Scalability

• 4 Architecture Issues When Scaling Web Applications: Bottlenecks, Database, CPU, IO
• Scaling Stateful Objects
• Scale Up vs Scale Out: Hidden Costs
• Best Practices for Scaling Out
• Scalability Worst Practices
• Reddit: Lessons Learned From Mistakes Made Scaling To 1 Billion Pageviews A Month
• Autoscaling Pinterest
• Square: Autoscaling Based on Request Queuing
• PayPal: Autoscaling Applications
• Trivago: Your Definite Guide For Autoscaling Jenkins
• Scryer: Netflix’s Predictive Auto Scaling Engine

Consistent Hashing

• Consistent Hashing
• Consistent Hashing: Algorithmic Tradeoffs
• Distributing Content to Open Connect
• Consistent Hashing in Cassandra

Distributed Database

• Life Beyond Distributed Transactions
• How Sharding Works
• Why you don’t want to shard
• How to Scale Big Data Applications.pdf
• MySQL Sharding with ProxySQL

Cache

• Cache update routine (:cn: CN)
• Design Of A Modern Cache
• Netflix: Caching for a Global Netflix
• Facebook: An analysis of Facebook photo caching
• How trivago Reduced Memcached Memory Usage by 50%
• Caching Internal Service Calls at Yelp

Message Queue

• Understanding When to use RabbitMQ or Apache Kafka
• Trello: Why We Chose Kafka For The Trello Socket Architecture
• LinkedIn: Running Kafka At Scale
• Should You Put Several Event Types in the Same Kafka Topic
• Billions of Messages a Day - Yelp’s Real-time Data Pipeline
• Uber: Building Reliable Reprocessing and Dead Letter Queues with Kafka
• Uber: Introducing Chaperone: How Uber Engineering Audits Kafka End-to-End
• Uber: Uber’s Real-Time Push Platform
• Publishing with Apache Kafka at The New York Times
• Kafka Streams on Heroku
• Salesforce: How Apache Kafka Inspired Our Platform Events Architecture
• Exactly-once Semantics are Possible: Here’s How Kafka Does it
• Delivering billions of messages exactly once
• Benchmarking Streaming Computation Engines at Yahoo!

Log

• Using Logs to Build a Solid Data Infrastructure - Martin Kleppmann
• Building DistributedLog: High-performance replicated log service
• LogDevice: a distributed data store for logs

Performance

• Understand Latency
• Common Bottlenecks
• Performance is a Feature
• Make Performance Part of Your Workflow 📙 Designing for Performance
• CloudFlare: How we built rate limiting capable of scaling to millions of domains

Search

• Instagram: Search Architecture
• eBay: The Architecture of eBay Search.pdf
• eBay: Improving Search Engine Efficiency by over 25%
• LinkedIn: Introducing LinkedIn’s new search architecture
• LinkedIn: Search Federation Architecture at LinkedIn
• Slack: Search at Slack
• DoorDash: Search and Recommendations at DoorDash
• Twitter: Building a complete Tweet index
• Pinterest: Manas: High Performing Customized Search System
• Sherlock: Near Real Time Search Indexing at Flipkart
• Airbnb: Nebula: Storage Platform to Build Search Backends

Architecture Practices by Companies

• YouTube Architecture
• Scaling Pinterest
• Google Architecture
• Scaling Twitter
• The WhatsApp Architecture
• Flickr Architecture
• Amazon Architecture
• Stack Overflow Architecture
• Pinterest Architecture
• Tumblr Architecture
• Instagram Architecture
• TripAdvisor Architecture
• Scaling Mailbox
• Salesforce Architecture
• ESPN's Architecture At Scale - Operating At 100,000 Duh Nuh Nuhs Per Second
• Uber Architecture
• Dropbox Design
• Splunk Architecture

Microservice

• Martin Fowler: Microservices Guide

• Martin Fowler: Microservice Architecture

• AWS: What are Microservices?

• Microsoft: Microservices architecture style

• Pivotal: Microservices

• Uber: Introducing Domain-Oriented Microservice Architecture

• Uber: Designing Edge Gateway, Uber’s API Lifecycle Management Platform

• Microservice Architecture https://microservices.io

• 📙 IBM: Microservices Best Practices for Java.pdf

• 📙 Building MicroService

• Google: API Improvement Proposals

• Nginx

  • Introduction to Microservices
  • Building Microservices: Using an API Gateway
  • Building Microservices: Inter-Process Communication in a Microservices Architecture
  • Service Discovery in a Microservices Architecture
  • Event-Driven Data Management for Microservices
  • Choosing a Microservices Deployment Strategy
  • Refactoring a Monolith into Microservices

• Auto0 Blog

  • An Introduction to Microservices, Part 1
  • API Gateway. An Introduction to Microservices, Part 2
  • An Introduction to Microservices, Part 3: The Service Registry
  • Intro to Microservices, Part 4: Dependencies and Data Sharing
  • API Gateway: the Microservices Superglue

API Gatway

• Kubernetes api gateway
• Uber: Designing Edge Gateway, Uber’s API Lifecycle Management Platform
• Uber: The Architecture of API gateway
• Uber: Scaling of Uber’s API gateway

Microservice VS SOA, IaaS, Paas, Monolithic

• 📙 Microservices vs. Service-Oriented Architecture

• DZone: Microservices vs. SOA

• DZone: Microservices vs. SOA - Is There Any Difference at All?

• Microservices, SOA, and APIs: Friends or enemies?

• PaaS vs. IaaS for Microservices Architectures: Top 6 Differences

• Microservices vs. Monolithic Architectures: Pros, Cons, and How Cloud Foundry (PaaS) Can Help

• Microservices - Not A Free Lunch!

• The Hidden Costs Of Microservices

Practice

• Mircroservcie with Spring-Boot
  • Part 1 - Getting Started with Microservices Architecture
  • Part 2 - Creating Forex Microservice
  • Part 3 - Creating Currency Conversion Microservice
  • Part 4 - Using Ribbon for Load Balancing
  • Part 5 - Using Eureka Naming Server

• The Hidden Costs Of Microservices
• Microservice Antipatterns and Pitfalls
• Microservice Architecture: All The Best Practices You Need To Kno
• Best Practices for Building a Microservice Architecture
• Simplicity by Distributing Complexity
• Effective Microservices: 10 Best Practices

Authentication & Authorization

• ForgeRock: Identity Gateway
• ForgeRock: Token Validation Microservice
• Bringing Token state consistency to the Edge

Design Pattern

• Microservice Architecture and its 10 Most Important Design Patterns
  • Database per Microservice Event Sourcing CQRS Saga BFF API Gateway Strangler Circuit Breaker Externalize Configuration Consumer-Driven Contract Testing
• Modularity and Information Hiding.pdf
• Separation of Concern
• Service Oriented Architecture

Cloud Native

• Architecting Cloud Native .NET Applications for Azure

Cloud Computing

IO Virtualization

• Introducing virtio-networking: Combining virtualization and networking for modern IT
• Introduction to virtio-networking and vhost-net
• Deep dive into Virtio-networking and vhost-net
• Hands on vhost-net: Do. Or do not. There is no try

---

• A journey to the vhost-users realm
• How vhost-user came into being: Virtio-networking and DPDK
• Hands on vhost-user: A warm welcome to DPDK
• Virtqueues and virtio ring: How the data travels
• Packed virtqueue: How to reduce overhead with virtio

---

• Achieving network wirespeed in an open standard manner: introducing vDPA
• How deep does the vDPA rabbit hole go?
• Introduction to vDPA kernel framework
• vDPA kernel framework part 1: vDPA bus for abstracting hardware
• vDPA kernel framework part 2: vDPA bus drivers for kernel subsystem interactions
• https://www.redhat.com/en/blog/hyperscale-virtiovdpa-introduction-one-control-plane-rule-them-all
• Hardening Virtio for emerging security usecases

Edge Computing

• What is edge computing?
• Red Hat's edge computing approach
• The latest news and announcements on edge computing
• Evaluate your edge capabilities

Thanks

This roadmap is highly inspired by course: https://time.geekbang.org/column/intro/48. Thanks Hao Chen.