• In a chain of models every arrow is a handover, and uncertainty is approximated at each one
• The UK Community Infection Survey ran this way. Outside modellers saw summarised prevalence estimates
• Fitting the streams together avoids the handovers. Each model still gets written from scratch
• We want the components to be reusable, not the model

• The community of epinowcast. People who did not write the code answering each other
• The technical coherence of SciML. Shared interfaces, and downstream CI run against packages it does not own
• The ecosystem shape of Turing. Small packages other people build on
• And the curation of rOpenSci. Software peer review and a written package guide. Julia has nothing like it

• I started epinowcast in 2021 to be the modular one. It still cannot be taken apart into pieces anyone else can use
• The same structural request has been written down in EpiNow2 four times since 2020. Two closed as done and left the package no easier to take apart. Two are still open
• We wrote down a workflow for building these models, then could not follow it with the tools we had built

• A. Composed distributions with their own fitting layer. rand simulates a case, logpdf scores one
• B. Turing submodels. Joint inference and the whole toolchain, and one PPL’s design decisions with it
• C. SciML. A delay lowered into a generator, with solvers and sensitivities. Inference supplied separately
• D. A model written by hand. What everyone does now, and the baseline the other three have to beat
• We run all of them because I cannot tell you which is right

• A real model needs a PPL, and a PPL needs gradients through every component. AD is a requirement, not a feature
• Nobody has written down what supporting AD means, so we picked a definition and made CI defend it
• DifferentiationInterfaceTest does the correctness testing. On top, a package declares which scenarios are broken on which backend, and CI re-runs them
• In my view none of the six is reliably best, and each is kept going by a small team

• logpdf(Gamma(k, θ), x) computes xlogy(k - 1, x / θ). Mooncake has no rule for xlogy, so it differentiates the implementation. At shape 1.0 the first argument is zero, the iszero branch returns a constant, and the gradient comes back as zero
• Nothing throws. The sampler runs. The number is wrong
• EpiAwareADTools.jl carries the rule, and deletes it the day Mooncake ships one

• In R a package arrives with a definition of good already attached. R CMD check, CRAN policy, and rOpenSci review if you want it
• In Julia you get Aqua, and after that you decide. We decided on nine checks that run in every package
• JET is one of the nine. Benchmarking and the per-backend AD tests run alongside them
• All of it is CI, and the CI is now the thing to maintain. 8,600 lines of Julia hold ten of the eleven packages rigid

• Julia’s default is a docstring if you feel like it. Asking for them did not work, so the template tests for them
• Public symbols need a docstring in the standard format. The README’s Julia blocks run at docs build, so a broken example fails it
• Fourteen standards are written down, each naming the check that catches a breach or saying plainly that a human has to
• The banned word list is one of those checks. A README that calls itself comprehensive does not ship

• We have been applying for funding to do this properly, so far without success. We started anyway, with coding agents
• 966 merged pull requests in the EpiAware org from the bot account, and 119 closed unmerged
• No outside contributors so far, and no open good first issue on any package. Whoever writes the next one is likely to be a model
• On the DRC outbreak model the agents wrote the tests as well as the code. I read fewer of them than I should, and I do not have a defence for that

• PkgTemplates.jl composes the plugins you pick. BestieTemplate.jl is a Copier template, applied to an existing package a feature at a time
• Both are built to be chosen from. We wanted every package identical, so that whatever writes the next one has one shape to copy
• Neither covers the opinionated part, per-backend AD testing and benchmarking
• CI comes from one central .github, as SciML does, and EpiAwarePackageTools.jl overwrites the callers weekly. Its standards page is written for a model to read

1. What is the smallest governance you can start with? JuMP and SciML have written theirs. Turing has not. None of them says how an org starts, or how a package joins one.

2. Julia has no rOpenSci. Should it? No maintenance status labels, no disputes procedure. How do I decide whether to depend on a one-maintainer package?

3. Who tells a user which backend works for a model built from five packages? DifferentiationInterface answers for a function. Nothing composes.

4. How do you release eleven packages that have to work together? SciML runs downstream CI outside its own org. That is workflow files rather than guidance, and nothing publishes a tested version set. Twenty when we get there.

• epiaware.org — the packages, the docs, and how to get involved
• github.com/EpiAware — including EpiAwarePackageTools.jl and EpiAwareADTools.jl
• BVDOutbreakSize — the live DRC outbreak size model
• The prompts that wrote these decks

• Dashed is an empty repository
• Ten of the eleven packages are registered in General. ScoringRules.jl is not
• EpiAwarePackageTools.jl and EpiAwareADTools.jl are the two that hold the rest rigid

• Sep. ComposedDistributions.jl green on all six backends, ScoringRules.jl registered, and the documentation site level with main rather than trailing it
• Dec. GenerationTime.jl and ReproductionNumber.jl, the two empty repositories, are the disease dynamics pieces the abstract promised
• Mar. A governance document saying how a package joins and who decides, and a contributing guide that names a first task

• SpeedyWeather.jl is the size and shape we are aiming at. One domain, a handful of packages, and users who are modellers rather than developers
• The abstract for this talk says we have one package and an R prototype, EpiAwareR. It is ten packages out of date

• DifferentiationInterface tells you about a function. Turing tells you what Turing tests. Nothing tells you about a model assembled from five packages that each tested on their own
• The one public per-backend table for a probabilistic programming stack, TuringLang/ADTests, was archived in June

What we said we would build

flowchart LR
  DJ["Distributions.jl"]
  EXT["Censored<br>Convolved<br>Modified<br>Reparameterised"]
  CMP["Composed<br>Distributions.jl"]
  LOW["Lowered<br>Distributions.jl"]
  A["A<br>Distributions<br>Inference.jl"]
  B["B<br>ComposableTuring<br>IDModels.jl"]
  C["C<br>SciML<br>solvers"]
  SCR["Scoring<br>Rules.jl"]
  NXT["Generation<br>Time.jl<br>Reproduction<br>Number.jl"]

  DJ --> EXT --> CMP
  DJ --> LOW --> C
  CMP --> A --> SCR
  CMP --> B --> SCR
  C --> SCR
  NXT -.-> CMP
  NXT -.-> B

  classDef empty stroke-dasharray:6 4,color:#777,stroke:#777
  class NXT empty

Dashed is empty. A, B and C share the same objects.

What holds it together

• EpiAwarePackageTools.jl, up to 69 files per package, nine checks
• Six autodiff configurations in CI, from one list
• 8,600 lines of Julia to hold ten packages rigid

What we cannot answer

1. What is the smallest governance an ecosystem can start with?
2. Julia has no rOpenSci. Should it?
3. Who tells a user which backend works for a model built from five packages?
4. How do you release eleven packages that have to work together?