notes

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs

books.txt (4888B)

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