Leanpub Header

Skip to main content

Filters

Books

  1. Certainty by Construction
    Certainty by Construction
    Software and Mathematics in Agda
    Sandy Maguire
    No Description Available
  2. Understanding Drupal: A Complete Guide to Caching Layers

    Drupal's caching system is powerful only when you understand how its layers connect. This book walks you through cacheable metadata, render caching, HTTP headers, and reverse proxy configuration; the complete stack from page assembly to CDN edge.

  3. Build Your Own GPT From Scratch
    Build Your Own GPT From Scratch
    Train a Tiny Language Model on Your Laptop and Chat With It in Your Browser
    Sourabh Somani

    Build a tiny GPT from scratch, train it on your laptop in minutes, and chat with it in your browser. No API, no pretrained model, no GPU: just clear steps and code you understand line by line.

  4. Irreplaceable
    Irreplaceable
    Learn the craft of working with AI, and your value goes up, not away.
    Duncan McTavish

    Written for people who never asked to become AI users and now are. Not a tour of the technology, but a practical guide to working with it well — the habits that make good results repeatable, and the judgement to know when to check.

  5. Android App Architecture Mastery (2026 Edition)
    Android App Architecture Mastery (2026 Edition)
    Design Scalable, Modular & Production-Ready Apps with Clean Architecture, MVVM, MVI, Hilt & Modern Android Tools
    A.P. Pyre

    Build Android applications that scale with confidence. Android App Architecture Mastery (2026 Edition) delivers a production-focused blueprint for designing modular, testable, and maintainable apps using Clean Architecture, MVVM, MVI, Kotlin Coroutines, Flow, Hilt, Jetpack Compose, and modern Android engineering best practices.

  6. Leading Engineering Teams in the AI Era
    Leading Engineering Teams in the AI Era
    The manager's playbook for AI-native engineering organizations
    CAIO INCAU

    The first book that addresses engineering management specifically for the AI-native era. Classic EM books like The Manager's Path and An Elegant Puzzle predate agentic coding tools — this one starts where they left off. Every chapter produces a concrete artifact: a hiring rubric, a performance calibration guide, a budget template, a rollout plan. By the end, you have a complete management playbook for leading engineering teams where agents write most of the code.

  7. Gradual Modularization for Ruby and Rails
    Gradual Modularization for Ruby and Rails
    Improve collaboration, system design, and flexibility
    Stephan Hagemann

    Get yourself a new tool to manage your Rails application and your growing engineering organization! Prevent the ball-of-mud (and fix it!). Go for microservices or SOA if it makes sense not just because you don't have any other tool. Do all this through a low-overhead tool: packages. Enable better conversations to make practical changes today.

  8. Decision-making for Software Development Teams
    Decision-making for Software Development Teams
    Learn how to make mindful decisions in complex software ecosystems
    Francesco Strazzullo

    Learn how to make mindful decisions in complex software ecosystems

  9. The Engineer’s Grok Bot Playbook
    The Engineer’s Grok Bot Playbook
    Build a personal AI team, improve engineering outcomes, and connect your work to a second brain
    Geison Goes

    Build a personal team of Grok Bot assistants and a second brain that preserves what you learn, without handing over your judgment or your security boundaries. This evidence-first playbook gives software engineers the roles, prompts, workflows, and metrics to test what actually improves their work.

  10. Rusty Graphs - AI Ready Graphs for Rust Developers

    Language models guess. Knowledge graphs know. Rusty Graph shows you how to build a local AI agent whose memory is a real knowledge graph — typed, validated, reasoned over, and queryable with SPARQL — all inside a single static Rust binary. No JVM. No Docker sidecar. No Python runtime bolted to the side. You will build Ares a research-assistant agent that observes papers, forms beliefs, makes promises to other agents, and tracks the provenance of every fact it holds. Chapter by chapter, Ares grows from an empty Cargo workspace into a full pipeline: > load → reason → validate → query → answer All of it in under a thousand lines of idiomatic Rust, using three crates that actually work today: `oxigraph`, `reasonable`, and `rudof_lib`. `grapfeo` You will learn how to- Model a domain as RDF triples and load them into an embedded store. - Write RDFS and OWL 2 RL axioms that infer trust, identity, and inverse relationships — automatically. - Guard your graph with SHACL shapes that reject bad data at the boundary, not in production. - Query everything with SPARQL, from simple lookups to federated queries across named graphs. - Wire the graph into a hybrid RAG pipeline so your LLM answers are grounded in facts, not vibes. Who it is forRust developers building agents, assistants, or any system where the answer "the model said so" is not good enough. You should be comfortable with Cargo and traits. You do **not** need any prior semantic-web background — every concept is introduced through Ares before any formal definition appears. Why Rust, why nowLocal agents are the next deployment target: a user's laptop, a Raspberry Pi, a WASM sandbox. Python cannot go there comfortably. Rust can. This book is the missing manual for the Rust side of the semantic web — the one that tells you exactly which crates work, where the ecosystem is thin, and how to ship anyway. Stop hoping your model tells the truth. Give it a graph that does.

  11. User Needs Mapping
    User Needs Mapping
    Aligning Teams Around What Matters
    Rich Allen

    Most teams don’t suffer from a lack of effort—they suffer from a lack of alignment. Goals are misaligned, boundaries are unclear, and work often centres on internal priorities instead of user needs— resulting in frustration and delays. User Needs Mapping: Aligning Teams Around What Matters offers a practical, visual way to reconnect organisations with the people they serve. Instead of guessing at structure or copying someone else’s model, this book shows you how to expose hidden dependencies, identify genuine user needs, and make better choices about team design and responsibilities. Through real-world case studies and step-by-step guidance, you’ll learn how to navigate tensions between wants, needs, and feasibility, create clarity of purpose, and build teams that deliver meaningful outcomes. Whether you’re a leader, product manager, architect, or change agent, this book equips you to turn complexity into clarity and enable teams to flow faster—aligned around what matters.

  12. Mastering LLM Quantization: Architecture and Code

    A Comprehensive Engineering Guide to Low-Precision AI, Quantized Inference, GPU Kernels, and Production DeploymentQuantization is one of the key techniques for making large language models more efficient. By representing weights, activations, and other model data at reduced precision, engineers can lower memory requirements, improve hardware utilization, and potentially increase inference throughput. Achieving these benefits, however, requires careful trade-offs between numerical accuracy, computational cost, memory bandwidth, and hardware support. Mastering LLM Quantization: Architecture and Code is a 44-chapter engineering reference covering the mathematics, algorithms, implementation techniques, GPU kernels, evaluation methods, and deployment systems behind quantized language models. It connects theoretical foundations with practical approaches to building and optimizing low-precision inference pipelines.

  13. Practical Nix for DevOps & Platform Engineering
    Practical Nix for DevOps & Platform Engineering
    From Zero to Production - Reproducible Systems at Scale
    Steve Publications

    Master Nix without the usual frustration. This practical guide takes you from your first reproducible development environment to production ready infrastructure with clear explanations and real examples. Learn the patterns that help DevOps and platform teams build reliable systems that scale with confidence.

  14. Team Guide to Software Operability
    Team Guide to Software Operability
    Proven techniques for making software work well
    Matthew Skelton, Alex Moore, and Rob Thatcher

    Learn how a focus on software operability helps to increase system reliability, reduce problems in Production, and reduce total cost of ownership (TCO).

  15. Windows 10 System Programming, Part 1
    No Description Available