Deep Dive Snakemake

Page Maps

graph LR
  family["Reproducible Research"]
  program["Deep Dive Snakemake"]
  section["Course home"]
  page["Deep Dive Snakemake"]
  capstone["Capstone evidence"]

  family --> program --> section --> page
  page -.applies in.-> capstone

flowchart LR
  orient["Orient on the page map"] --> read["Read the main claim and examples"]
  read --> inspect["Inspect the related code, proof, or capstone surface"]
  inspect --> verify["Run or review the verification path"]
  verify --> apply["Apply the idea back to the module and capstone"]

Read the first diagram as the shape of the whole book. Read the second diagram as the intended route so the capstone and support shelves do not become accidental first lessons.

Deep Dive Snakemake teaches workflow design as a discipline of explicit file contracts, deterministic planning, safe dynamic behavior, and durable operational boundaries. The goal is not to collect workflow tricks. The goal is to build workflows another engineer can inspect, trust, and extend without folklore.

Use this course if

• you want a workflow model instead of disconnected Snakemake snippets
• you inherited a pipeline that runs but is hard to trust, review, or extend
• you already use Snakemake and now need stronger publish, profile, and workflow-boundary judgment
• you review whether a workflow can survive CI, shared filesystems, and long-lived change

Do not use this course as

• a syntax refresher detached from workflow contracts
• executor advice before workflow meaning is clear
• a reason to use dynamic behavior without explicit discovery and publish boundaries

Choose one starting lane

If you are here because...	Start with	Stop when you can say...
Snakemake is still new	Start Here, Course Guide, Module 00	what a truthful file contract is and why the capstone is not your first lesson
you need to repair an existing workflow	Pressure Routes, Module 03, Module 04	whether the problem is workflow semantics, policy drift, interface sprawl, or incident pressure
you steward a long-lived workflow repository	Course Guide, Module 06, Module 07	which surfaces are public, which are policy, and which proof route is proportionate

Keep these support pages nearby

Need	Best page
shortest stable entry	Start Here
route shaped by urgency	Pressure Routes
stable support hub	Course Guide
module titles translated into promises	Module Promise Map
module exit bar	Module Checkpoints
workflow split decisions	Boundary Review Prompts
smallest honest proof route	Proof Ladder
capstone entry by module and question	Capstone Map

Module Table of Contents

Module	Title	Why it matters
Module 00	Orientation and Study Practice	establishes the entry route, proof surfaces, and capstone timing
Module 01	File Contracts and Workflow Graph Truth	teaches the workflow as a file-driven DAG instead of a script
Module 02	Dynamic DAGs, Discovery, and Integrity	teaches deterministic discovery, checkpoint discipline, and publish integrity
Module 03	Production Operations and Policy Boundaries	teaches profiles, recovery policy, staging discipline, and production proof routes
Module 04	Scaling Workflows and Interface Boundaries	teaches rule-family splits, module interfaces, file APIs, and scaling review gates
Module 05	Software Boundaries and Reproducible Rules	teaches software ownership, runtime contracts, provenance, and rebuild judgment
Module 06	Publishing and Downstream Contracts	teaches public bundle design, compatibility discipline, integrity evidence, and publish review
Module 07	Workflow Architecture and File APIs	teaches repository layers, file-api boundaries, helper placement, and architecture review
Module 08	Operating Contexts and Execution Policy	teaches profile boundaries, failure policy, storage assumptions, and context-drift review
Module 09	Performance, Observability, and Incident Response	reviews logs, benchmarks, and incidents with explicit evidence
Module 10	Governance, Migration, and Tool Boundaries	finishes with stewardship and tool-boundary judgment

How the capstone fits

The capstone is the executable proof surface for the course. It should corroborate a module idea that is already legible, not replace first exposure.

Use it in this order:

1. learn the concept in the local module exercise
2. choose the smallest honest route with Proof Ladder
3. enter the repository through Capstone Map or Command Guide
4. escalate to stronger review only when the current question actually needs it

Success signal

The course home has done its job when you know:

• where to start without random browsing
• which support page answers the next question
• why the capstone is a proof surface rather than a first-contact playground
• why later modules are consequences of earlier file-contract and publish-boundary choices

Failure modes this course is designed to prevent

• treating a workflow as a script rather than a file-driven DAG
• trusting a workflow because it ran once instead of because its contracts and proofs are visible
• using the capstone as first contact and confusing repository size with conceptual clarity
• treating publish, profile, and governance pages as substitutes for earlier workflow truth