notes

Log | Files | Refs | README

books.md (4747B)

      1 # Books
      2 
      3 ## TypeScript
      4 
      5 [TypeScript Deep Dive](https://basarat.gitbook.io/typescript/future-javascript/arrow-functions) -
      6 This is great and succinct and freely available online
      7 
      8 Effective TypeScript by Dan Vanderkam - very useful
      9 
     10 ## Fundamentals of Software Engineering
     11 
     12 The Pragmatic Programmer by Andrew Hunt, David Thomas (The Pragmatic Programmer:
     13 Your Journey to Mastery, 20th Anniversary Edition)
     14 
     15 The Mythical Man-Month
     16 
     17 Become an Effective Software Engineering Manager
     18 
     19 Site Reliability Engineering: How Google Runs Production Systems
     20 
     21 Clean Code by Robert C Martin
     22 
     23 A Philosophy of Software Design
     24 
     25 ## Additional Software Engineering Reading
     26 
     27 Fundamentals of Software Architecture: An Engineering Approach
     28 
     29 Code Complete by Steve McConnell
     30 
     31 JavaScript: The Good Parts
     32 
     33 Design Patterns: Elements of Reusable Object-Oriented Software
     34 
     35 Refactoring by Martin Fowler
     36 
     37 Test-Driven Development by Example by Kent Beck
     38 
     39 ## Rust
     40 
     41 [Rust Atomics and Locks](https://mara.nl/atomics/)
     42 
     43 Programming Rust, 2nd Ed. — Jim Blandy & Jason Orendorff Why: The definitive
     44 reference on Rust’s ownership, borrowing, and unsafe code. Covers lifetimes,
     45 async/await, and concurrency primitives in depth. Written by core language
     46 designers.
     47 
     48 Rust in Action — Tim McNamara Why: Focuses on systems programming patterns
     49 (including allocators, FFI, and unsafe code) and includes practical async/Tokio
     50 examples. Strong on performance-aware design.
     51 
     52 ## Low-Latency Systems, Hardware-Aware Optimization & Allocators
     53 
     54 Designing Data-Intensive Applications — Martin Kleppmann Why: Though not
     55 Rust-specific, it’s essential for understanding latency, consistency, and
     56 distributed system trade-offs. Covers observability, ordering, exactly-once
     57 semantics, and system boundaries—directly relevant to your messaging and
     58 observability needs.
     59 
     60 High Performance Browser Networking — Ilya Grigorik Why: Surprisingly
     61 relevant—covers TCP/UDP, zero-copy, kernel bypass concepts, and NUMA-aware
     62 design patterns. Though focused on browsers, its low-level networking insights
     63 translate directly to systems programming.
     64 
     65 The Linux Programming Interface — Michael Kerrisk Why: The most comprehensive
     66 reference on Linux syscalls, I/O models (including io_uring), and memory
     67 management. Critical for understanding zero-copy, custom allocators, and
     68 hardware-level profiling.
     69 
     70 ## System Design, Architecture & Leadership
     71 
     72 System Design Interview (2 vols) — Alex Xu Why: Excellent for scaling and
     73 distributed system design patterns—especially useful for Kafka/NATS-style
     74 systems and observability architecture.
     75 
     76 Accelerate — Nicole Forsgren et al. Why: Evidence-based practices for DevOps,
     77 CI/CD, and performance regression detection. Directly supports your CI/CD and
     78 benchmarking-gates requirements.
     79 
     80 The Pragmatic Engineer — Gustavo Sampaio Why: Covers architecture reviews, ADRs,
     81 and engineering standards—ideal for leading Rust engineering culture
     82 
     83 ## Observability, Testing & Reliability
     84 
     85 Observability Engineering — Candace Gonzalez et al. Why: Covers
     86 Prometheus/OpenTelemetry, tracing, alert design, and structured logging in
     87 production systems—aligned with your observability stack.
     88 
     89 Chaos Engineering — Casey Rosenthal et al. Why: The foundational text on fault
     90 injection, chaos testing, and resilience design—directly matches your “chaos and
     91 fault injection experience” requirement.
     92 
     93 Property-Based Testing with Rust — John A. De Goes (free online) Why: While not
     94 a traditional book, De Goes’ Modern Software Engineering and his PBT tutorials
     95 are widely used in Rust for property-based testing and TDD as design discipline
     96 
     97 ## Cloud Infrastructure (Azure/AWS)
     98 
     99 Cloud Native Infrastructure — Karl Isenberg & George Miranda Why: Covers IAM,
    100 secrets management, and infrastructure-as-code patterns across cloud
    101 providers—including Azure-specific guidance.
    102 
    103 Designing Distributed Systems — Brendan Burns Why: Written by a Kubernetes
    104 co-creator; emphasizes patterns for reliability, observability, and managed
    105 services—highly applicable to Azure/AWS deployments
    106 
    107 ## Supplemental (Free & Online)
    108 
    109 [The Rust Async Book](https://rust-lang.github.io/async-book/)
    110 
    111 [The Rustonomicon](https://doc.rust-lang.org/nomicon/)
    112 
    113 [Tokio docs & blog](https://tokio.rs/blog/)
    114 
    115 io_uring & DPDK deep dives (e.g.,
    116 [A Deep Dive into Zero-Copy Networking and io_uring](https://medium.com/@jatinumamtora/a-deep-dive-into-zero-copy-networking-and-io-uring-78914aa24029),
    117 [Zero-copy network transmission with io_uring](https://lwn.net/Articles/879724/))
    118 
    119 ## Personal Development
    120 
    121 Deep Work by Carl Newport
    122 
    123 How to measure anything
    124 
    125 Tidy First
    126 
    127 Becoming Evil: How Ordinary People Commit Genocide and Mass Killing by James
    128 Waller
    129 
    130 The Art of Memory - Frances Yates