The ALA Checklist: eleven rules, applied by hand
The thermometer post distills ALA to four rules you can keep in your head. This is the full instrument: the ALA Checklist, eleven rules that turn John Spray’s constraints into things you can actually check, some by a machine and some only by a reader. I walk all eleven against the same thermometer, one at a time, because doing the checklist by hand once shows you exactly where a linter helps and where it has to hand the judgement back to you.
The checklist itself lives in its own repo, in two editions with the same rules, notation and citations: a general edition for any functional language, and an Elixir edition with Elixir and Phoenix LiveView code for each technique. This post’s examples are in Elixir.
If you have not read the thermometer post, read it first: this post assumes its bad and good versions, its notation, and the four-rule core.
A quick recap of the code
The good thermometer splits the computation by altitude. The domain abstractions are generic and know nothing about thermometers:
defmodule OffsetAndScale do
defstruct [:offset, :scale]
def apply(%__MODULE__{offset: o, scale: s}, value), do: (value + o) * s
end
defmodule LowPassFilter do
defstruct [:strength, :last_output]
def smooth(%__MODULE__{} = f, input) do
output = f.last_output + (input - f.last_output) / f.strength
{output, %{f | last_output: output}}
end
end
The application layer is the only place that knows this is a thermometer, and it does the wiring:
defmodule Thermometer do
defstruct [:oas, :lpf, :sample, :display]
def new(opts \\ []) do
%__MODULE__{
oas: %OffsetAndScale{offset: -200, scale: 0.2},
lpf: %LowPassFilter{strength: 10, last_output: Keyword.get(opts, :lpf_initial, 40.0)},
sample: %SampleEvery{n: 10},
display: %Display{label: "Temperature", units: "C"}
}
end
def push_reading(%__MODULE__{} = therm, reading) do
scaled = OffsetAndScale.apply(therm.oas, reading)
{smoothed, lpf} = LowPassFilter.smooth(therm.lpf, scaled)
{sampled, sample} = if smoothed, do: SampleEvery.tick(therm.sample, smoothed), else: {nil, therm.sample}
display = if sampled, do: Display.record(therm.display, sampled), else: therm.display
%{therm | lpf: lpf, sample: sample, display: display}
end
end
What Spray means by a domain abstraction
Before the rules, one word needs pinning down, because it trips people up. When Spray says domain abstraction, he doesn’t mean a domain model of business entities. He means abstractions “specific to the types of applications we want to express using them”, reusable “within a single application and by other applications in the same domain” (§2.2). For a storefront that includes a grid of cart lines, a promo rule, a store adapter and a payment call. The layer holds “building blocks for I/O, data transformations, and persistent state, but many other types of abstractions are possible” (§2.2).
He doesn’t give UI a layer of its own either. “We don’t separate UI from business logic and data models as we do in conventional architectural layering patterns” (Summary). A user story keeps them together, and what’s separated is each abstraction’s implementation. What makes something a UI abstraction is its ports.
- A UI-layout port. “An instance of display could be put inside an instance of a panel” (Summary), and composing UI means “containing one UI element inside another” (§3.5.1). A UI-layout port connects only to another UI abstraction, because a port’s type is a paradigm.
- Dataflow in, for what it shows. His Grid “is able to pull rows of data as needed” from the reader and filters it’s wired to.
- Events out, and inputs too. GUI elements “have event-driven output ports”, and popups and pages have input ports (§3.5.1).
Data sources are abstractions of their own: “connect the UI elements that display data to some data sources. These data source are candidates for abstractions” (§5.2.2). The same goes for where data is saved. So data is wired into a UI abstraction, and the UI abstraction doesn’t fetch or persist. In a LiveView app, that’s the line between a function component that renders the rows it’s given and a component that loads and saves them. The checklist maps each LiveView piece onto these kinds.
What Spray means by a feature
The other word that trips people up is feature. Spray’s features are a layer an application gets only once it’s too big: “it is the application that will go over the 500 line complexity limit. ALA will need to be applied to the large application abstraction by adding a new layer below it” (§2.2). The application then “just composes a set of features or user stories needed in that specific application, and sets up any communication that may be needed between them” (§2.2).
A feature holds wiring, the same as the application does. “Each feature creates instances of domain abstractions, configures the instances with feature specific details, and connects them together as needed to express the feature or user story”, and “Feature abstractions can have ports” (§2.2). Its UI layout and “the bindings of the UI elements to data” are “kept together, encapsulated inside a feature” (§7.14). So R11’s “composition only” holds for features too. A module of state and rules with ports is a domain abstraction, whatever its namespace says. This project’s LiveView variants called theirs Features, and since 2026-10-02 the checklist scores that name as an R8 “should”.
The same reading settles page-specific LiveComponents. “There is no analog of a sub-module or sub-component, no such thing as a sub-abstraction. Abstraction layers replace hierarchical containment” (§2.2). A LiveComponent that only one page uses, with its own state and handlers (the FormComponent that phx.gen.live generates), is a sub-component the page contains, and an R11 finding.
The eleven rules, applied
I score ALA compliance against these eleven. R1 through R7 and R10 through R11 are checkable, some mechanically and some only by a reader; R8 is pure judgement and marks where automation stops; R9 is half-and-half. Here is the thermometer against each.
R1, every edge between abstractions drops to a lower layer. Thermometer (application) calls OffsetAndScale, LowPassFilter, SampleEvery, Display (domain). Application is more concrete than the generic abstractions, so every call drops. The abstractions call nothing but the standard library, so there are no peer calls (domain → domain) and no upward calls. Pass.
R2, wires meet only at the top. No value is shared between two abstractions except through the composition, and there is no shared mutable state for two peers to read. State lives in each abstraction’s struct, and the composition passes it explicitly. Elixir’s immutability hands you this rule for free, which is worth knowing: in an imperative language R2 is real work, here it is a language property, so a clean R2 says less about your design than it would in Rust. Pass, with an asterisk.
R3, application literals live at the composition. The magic numbers are all in new/1, the top layer: offset: -200, scale: 0.2, the sample rate, the starting value the composition supplies to the filter. The abstractions themselves hold no literal. That is exactly where requirements should read. Pass. (This is the rule that turns on a judgement the moment a literal is less clear-cut: had a starting value been baked into an abstraction’s struct default, a reader would have to decide whether it is an application literal to hoist or one intrinsic to the abstraction to keep. Here nothing is stranded below the top, so the question does not arise.)
Words are literals too, and this is the part of R3 that gets questioned most. Does Spray really mean that even the text a user reads is passed in? His practice says yes in every example: new Display(label: "Temperature") (§2.1.3), new TextBox(Label="Filter by name"), new Menu("File"), a wizard’s titles, even a status line wired in as a LiteralString("Connected to device"), and §7.14’s “Using one in a specific application only requires a label and a binding to an action.” His UI abstractions carry no words of their own. He never states it as a rule, so the checklist does, drawn from §1.6.3 and §2.4: a word that belongs to one product is requirement knowledge, and an abstraction that held it would not be reusable in §2.2’s sense. The checklist now adds the exception that makes the rule workable: a word the abstraction’s domain owns stays; a word the product owns moves. A date picker’s “Today”, a pager’s “Next”, a retail stock badge’s “Out of stock” are their abstractions’ vocabulary; “Your cart is empty.” and “Standard (5–7 days)” are this store’s. The reviewer’s test: would another product in the same domain keep this word? A linter can’t tell the two apart, so it reports every word below the composition and the reviewer decides in the code. The Elixir linter now reads two forms of that decision: a module attribute named @inherent_... holds words R3 treats as the abstraction’s own, and a comment accepts one finding for one named check:
@inherent_labels %{out_of_stock: "Out of stock", low: "Only %{n} left"} # the badge's own words
# ala:accept r3 -- "Standard" is the carrier's name, not this store's wording
def label, do: "Standard"
mix ala.lint --list-accepted prints every declaration and every acceptance with what it covers, and flags the stale ones. The point is to keep the rule and move the judgement where it belongs: into the code, signed by a person, visible to the next reader.
R4, state lives with its owner, not hidden. The filter’s memory is inside LowPassFilter and the sampler’s count inside SampleEvery, each owned by the abstraction whose concept it is. push_reading/2 stores the updated structs back without looking inside them. Nothing is stashed in the process dictionary or a module attribute. Pass. (Carrying each updated struct by hand is a different cost, Spray’s “handling the data”, which the follow-up post removes.)
R5, no silent contracts. A silent contract is agreement between two functions that no signature shows: a string format one side produces and another parses, a tuple shape, a shared magic key. The thermometer has none; the abstractions communicate through typed structs and return values. Pass.
R6, every abstraction names a learnable concept. OffsetAndScale, LowPassFilter, SampleEvery, Display. Each names something a reader can learn and the language does not already provide. None is a meaningless wrapper. Pass. Two tests from Spray confirm it: each separates the knowledge of different worlds (§7.2.5; calibration from raw counts, filtering from noise), and you can use each without following the reference into its body (“a good abstraction is when you don’t need to follow the indirection”; you can use LowPassFilter.smooth without reading it). This is also the rule an automated check gets wrong most often: my linter first flagged OffsetAndScale.apply as “just wraps arithmetic,” a false positive, because the function combines two named calibration fields into a formula. A human sees that instantly.
R6 also has a “should” that comes from Spray’s comparison with functional programming: a public function takes only parameters it uses itself. When plain functions call down through layers, “the middle layer functions end up with extra parameters that don’t have anything to do with them, just so they can pass state data through to even lower functions” (§3.11.1). The thermometer is too flat to have a middle layer. push_reading/2 hands reading straight to OffsetAndScale, the abstraction that processes it, which is one hop of use, not carrying. The linter’s advisory tramp check agrees and reports nothing.
R7, every abstraction earns its existence. Four small abstractions, none a trivial rename, and none internally decomposed into sub-parts (each is a cohesive whole readable in isolation, the R7 verify test). Spray never required a second caller, so single use is fine when the thing names a real concept. And reuse is a positive, never a smell. Pass.
This is where Spray’s “little balls of mud” idea lives. ALA governs the relationships between abstractions, not the purity of each one’s insides. The interior of an abstraction may be a little ball of mud: procedural, branchy, decomposed into private helpers. That is fine as long as the abstraction names one concept, stays bounded in size, keeps its internals private behind a small public surface, and is clean at its boundary. So the structural checks measure the graph of abstractions (modules and their public functions), not the raw call graph. A call from one private helper to another in the same module is internal decomposition; it adds no abstraction height and is never counted as a pass-through. The guardrails that keep a little ball of mud from becoming a big one are the first three: a module that stops being nameable, blows the size cap, or exposes a wide public API has leaked its mud outward, and that is the real defect, not the mess itself.
The public-surface count needs one more sentence, because the module is not an ALA concept and the function is. An abstraction has several ports, and in Elixir an input port is a public function, so the count of public functions on a state module is the count of input ports on one abstraction. One-function modules would be a port per module, which destroys the abstraction. The count is a proxy for “one concept” that a tool can read: a module well above the rest is probably two sharing a name, as V50’s cart state at 19 was. The default of 12 came from measuring the top variants: single-concept step machines and the lines value sit at 11 or 12, nothing sat at 13, and the two modules above were the two later split. That is one application’s evidence, which is why the check is advisory and tunable.
R8, the composition reads as the requirements. Read new/1 and push_reading/2 and you can state what the thermometer does and how it is calibrated. This is judgement, not shape, and it is where a reader has to actually think. Pass, in my reading.
R9, ports are typed by a programming paradigm; an abstraction owns no interface except its own configuration. Each domain abstraction’s struct fields are its configuration, set once by the application; at run time it takes a plain value and returns one. None knows where its input comes from or where its output goes (LowPassFilter does not know a thermometer feeds it). The values on the ports are numbers, not a struct one abstraction defines for another to match on, and no abstraction defines a @callback for a sibling to implement. Pass.
R9’s “should” asks that configuration be set once, apart from run-time data. Spray’s reason is in §3.9: passing configuration with every call “would also mix the data parameters of the function with the configuration parameters, breaking the Interface Segregation Principle.” Here new/1 builds each struct once with its configuration, and each call passes that struct first and the reading after it (OffsetAndScale.apply(therm.oas, reading)), so the settings never ride along with the data. Pass. His own §1.6.3 C code doesn’t do this yet (OffsetAndScale(adc, offset=4, slope=8.3) inside the loop), which is why it’s a “should”.
R10, no two features know the meaning of the same data. This rule needs features to violate, so a single-application thermometer can’t break it. It matters the moment you have several features on a page: no domain struct may be read by two features, so either can change its data’s shape without editing the other. Sharing only an identity key is one way to meet it, and it’s why V36 gives each feature its own private struct; projections and values the composition passes in are others. Not applicable here, which is itself the point.
R11, the composition layers are composition only: the application, and Spray’s Features when an app has them. The thermometer has no Features layer, so this is about its application. new/1 is pure configuration. push_reading/2 is wiring, but it carries two ifs: the sampler emits a value only every tenth reading, and the display updates only when there is one. That is conditional propagation of an optional value, so the linter stamps (branches) on it, and because two of the codebase’s six functions sit in the application layer, it also notes the layer is 33% of functions. Both are scored only under --super-strict. I used to clear these as Maybe-binds rather than business logic. By Spray’s standard that’s wrong. His application layer has “no normal programming language code such as assignments and if statements” (§3.5), and he flags this very if in his own thermometer as logic still to remove (§1.6.3). So this is a real R11 finding. The design passes at the default and --strict levels only because the linter scores R11 under --super-strict. The fix changes the code, not the reading: move the guard into the connection mechanism, so a stage with nothing to report passes nothing on (§1.6.4). The follow-up post does exactly that. The checklist’s R11 now sorts the kinds of if (guards, requirement conditions, history, outcome routes, ordering) and where each one goes, including a table for the forms a LiveView page contains.
One more thing R11 is often read as forbidding, and doesn’t: the page’s layout. A screen’s arrangement, what sits inside what, in which order, with which grid and spacing, is the least general thing in the app, and it is supposed to be. Spray writes it himself in the composition, in the UI-layout paradigm: “A relationship means put the target instance of a UI element inside the first instance of a UI element. The order of the fanout of relationships sets the order that the elements appear” (§4.12), and he keeps it with the story on purpose: “the layout of the UI is a small amount of information, and the bindings of the UI elements to data are a small amount of information. So all that cohesive knowledge is kept together, encapsulated inside a feature. Instead, the UI is composed from Domain UI abstractions” (§7.14). In LiveView that tree is the page’s HEEx:
<div class="grid items-start gap-8 lg:grid-cols-[1fr_22rem]">
<section class="rounded-2xl border bg-white p-6">
<.tabs tabs={@tabs} />
<.cart_lines rows={@rows} words={@words.cart} />
</section>
<aside class="lg:sticky lg:top-6">
<.cart_summary summary={@summary} words={@words.cart} />
<.shipping_selector summary={@summary} words={@words.cart} />
</aside>
</div>
The two columns, the sticky aside, the order, the gaps: the page’s own, product-specific, not a finding. The elements it places are domain UI abstractions, and the classes inside cart_summary are its own style, “suitability to their domain context” (§7.14), also not a finding. What R11 still catches in that template is logic, not layout: a :for over @rows in the page’s own markup, an :if on @summary.item_count == 0, a class={if @step == …}; each has a component that takes the value instead. And R3 still applies to the words: in a component’s markup they’re a finding, in the page’s they’re the product’s words in the product’s layer. The one place this pulls against Phoenix habit is exactly the quick :if in a page, which is why R11 scores only at the strictest tier.
The same reading settles where a framework’s entity goes. A resource or model with every use case’s behaviour attached to it (relationships, callbacks, notifiers, scheduled triggers) is the entity Spray rejects in §6.17.2; the usable slice is one entity per feature’s private data, keyed by an identity, with its intrinsic rules inside, reached as a configured store. The Ash post reads Ash that way piece by piece, and the Elixir edition now carries the table.
Required, advisory, judgement
Not every rule carries the same weight, and being honest about that is half the point of the checklist.
- Required (a machine can score them): R1, R2, R3, R4, R5, R6, R9’s owned-interface check, R10, and, given a layer map, layer validity. These are structural facts about the code. A violation is a defect, and
ala_lintfails the build on them. - Advisory (reported, not scored by default): R7 (earned existence), module size (over 500 lines), abstraction height, pass-through helpers, tramp parameters (R6’s “should”), a module subscribing itself to a topic (the bottom layer, where a technical domain is abstracted, may own its topic), and a reference-level R1 signal, the obtainable prompts, promoted into the score by
--strict. Spray never forced reuse, so these are a reading list, not gates, until you opt in. - Aspirational (scored only under
--super-strict): R11 (composition-layer purity: no logic in the application or a Features layer; aconnected?/1guard counts as routing) and a public-surface check (a module exposing a wide public API has stopped encapsulating its little ball of mud). These are purity targets, not always obtainable in a real app, so they are super-strict gates rather than CI gates. - Reported at every tier, scored by none: the application layer’s share of all functions, files averaging under 100 lines, and the shared-domain-aggregate reading of R10. Each is a ratio or a design choice (a shared aggregate is Spray’s ground symbol, §3.6.1) that a tier should not turn into a defect;
--enforcescores one when a team wants to. - Judgement (only a reader decides): R3’s “is this literal an application literal or intrinsic to the abstraction,” R6’s “does this name a real concept,” R8 in full, the rest of R9 (whether an output reads as a result, whether a struct is a peer’s DTO), and R10’s shared-aggregate case. This is where the tool stops and you begin.
That split is why the thermometer scores 100 at the linter’s default level yet still leans on a reader for the ones that matter most: whether the abstractions are the right ones (R6/R7) and whether the composition reads as the requirements (R8). The four-rule core is what you internalize; these eleven are how you check it precisely; and the linter runs the subset a machine can prove so your attention goes to the rest.
Adopting it gradually, tier by tier
You do not turn all eleven rules on at once. The three enforcement tiers are the adoption path: each is a strictness level of the linter and a set of checklist rules, and — because the encoding carries the same rules — a set of notation marks to get right. Start at the floor and climb only when the tier below is quiet.
Tier 1 — Required (mix ala.lint, the default). The structural facts: R1 edges drop, R2 wires meet only at the top, R3 application literals at the composition, R4 state owned, not hidden, R5 no silent contracts, R6 nameable abstractions, R9 no owned interfaces, R10 no shared entity, and layer validity once you declare a layer map. A violation here is a defect; this is the gate you put in CI first. In the encoding: get the [tag]s and @levels right so edges read as drops, confirm each $ and q, and resolve every {app-literal?} to {app-literal} or {intrinsic-literal}. A clean default run plus a completed encoding at this tier is a real, defensible floor: no gross coupling smells.
Tier 2 — Advisory (--strict). The obtainable prompts: R7 (earned existence), module size, abstraction height, pass-through helpers (~>), tramp parameters, self-subscription, and the reference-level R1 signal. Reported by default, so treat them as a reading list first; when the team agrees a signal is worth holding the line on, promote it — --strict scores them all, or --enforce height (equivalently a .ala_lint.exs entry) scores one. Spray never forced reuse, so nothing here fails your build until you opt in.
Tier 3 — Aspirational (--super-strict). The purity targets: R11 (no logic in the composition layers, the (branches) mark) and the public-surface check. The app-layer share and the shared-domain-aggregate reading of R10 (&aggregate) are reported alongside but never scored by a tier. Real apps do not always reach these (the thermometer fails R11 at Spray’s §1.6.3 step, with two guard ifs and handled data, and passes from §1.6.4 on), so they are a super-strict bar you aim at on greenfield or mature code, not a CI gate. Reach for this tier last, and read each flag as a question to answer rather than a defect to fix.
Underneath all three: judgement. R3’s application-vs-intrinsic call, R6’s “is this a real concept,” R8 in full, the rest of R9, and R10’s aggregate case are never scored at any tier. The tiers automate what they can so this judgement is where your attention lands. Per-check --enforce/--disable and a .ala_lint.exs file let you cherry-pick within a tier once the coarse levels feel too blunt.
Glossary
The checklist’s vocabulary, in alphabetical order. Section numbers point to Spray’s site. Where a term is this project’s and not Spray’s, the entry says so.
Abstraction. The only unit of code in ALA: “a ‘generalized conceptual idea’”, “learnable as a concept” (§2.1.1). In Elixir it is usually a module, sometimes a single function. What makes it an abstraction is that a reader can use it without reading its body.
Abstraction height. The longest chain of knowledge dependencies between abstractions. Calls inside one module don’t add height. A tall stack of thin layers is a sign of helper proliferation. A linter metric, not Spray’s term.
Application layer. The top layer. It instantiates abstractions, configures them, and wires them together, and holds all of the app’s specific knowledge and none of its logic (§3.5). In a LiveView app, the page, its template, and the router.
Application literal. A constant that belongs to this product (a price, a threshold, a label, message text). It lives at the composition (R3). Contrast intrinsic literal.
Communication dependency. One module calling another to move data or events between them as peers. ALA eliminates these; the layer above wires the peers instead.
Composition. Building something from instances of abstractions by connecting them. Spray’s opposite is decomposition, splitting a system into specific parts that collaborate (§3.7). “The composition” also names the code that does the composing: the application, or a feature’s wiring.
Configuration. The settings an instance gets once, when it is created: its main interface, used only by the layer above (R9). R9’s “should” keeps configuration apart from run-time data.
Connection mechanism. Whatever carries data along a wire at run time: a runner, with, a monad’s Bind. Guards like “only if there’s a value” belong here, not in the application (§1.6.4, §6.1.3).
Departure. A place where this checklist knowingly differs from Spray, with a reason, such as the routing clauses a LiveView page must keep. Recorded, kept small, never used for logic.
Diagram. Spray’s source of truth: boxes are instances, lines are wires, and the whole reads as the requirements (§2.5, §3.6). In Elixir it may be a manifest, a graph value, or a readable composition.
Domain abstraction. A reusable abstraction in the layer below the application (or below the features). It knows nothing about this product: LowPassFilter, OffsetAndScale, a generic table component.
DTO (data-transfer object). A type made only to carry data between two modules. Two peers may not share one (§4.8.1).
Execution model. The code that makes a kind of connection actually run, such as a runner, an interpreter, or LiveView’s event loop. It lives in the Programming Paradigms layer.
Feature. A product-knowing abstraction in its own layer under the application, wired by it, used once an application is too big to be one abstraction (§2.2, §7.15). Like the application, it holds instances, configuration and wiring, including its UI layout built from domain UI abstractions (§2.2, §7.14).
Ground symbol. Spray’s name for a wire that joins many ports, like ground on a schematic. It suggests a missing abstraction one layer down (§3.6.1).
Handling the data. The application catching one abstraction’s result only to pass it to another. Spray names it at his §1.6.3 step and removes it at §1.6.4. An R11 finding.
Identity key. An id two features share while each keeps its own data. One way to meet R10, and this project’s technique, not Spray’s wording.
Instance. The run-time use of an abstraction: a configured struct value, a process, or just a reference to a pure function (§3.2.2).
Intrinsic literal. A constant that is part of an abstraction’s own definition, such as an identity or a physical constant. It stays in the abstraction. Contrast application literal.
Knowledge dependency. One abstraction using another, more abstract one by name, the way code uses a square root. The only kind of dependency ALA allows, and it must point to something significantly more abstract (§2.1.3, §3.4).
Layer. One of a few levels ordered from concrete to abstract. Spray’s usual stack is Application, Features, Domain Abstractions, Programming Paradigms, and Foundation. Knowledge only flows down.
Little ball of mud. An abstraction’s inside, which may be procedural and messy as long as the abstraction is small, names one concept, and is clean at its boundary. ALA governs the relationships between abstractions, not their insides.
Monad. A functional pattern that composes functions through a Bind function, which hides execution details. Spray treats monads as the nearest functional analogue of ALA, and as more limited: two ports and one paradigm (§3.11, §6.1–§6.2).
Must / should. A “must” is a defect when it fails. A “should” is a prompt a reviewer weighs, used where Spray’s evidence is weaker.
Owned interface. An interface specific to one module, either defined by a consumer for others to implement (required) or by a module for its peers to call (provided). Both fail R9.
Pass-through. A public function with one caller whose body is a single call into another module. It renames a call without hiding a decision. A linter check, advisory.
Peer. Another abstraction in the same layer. Peers never know each other. Only a layer above connects them.
Port. An input or output of an instance whose type is a programming paradigm from a lower layer, set up by the layer above. In Elixir it’s often a protocol, a function passed in, or a pid.
Program value. An immutable composition (a chain or a circuit of configured structs) that its owner holds and feeds each input. It’s how Elixir keeps a program built once and run forever.
Programming paradigm. What a kind of connection means: dataflow, events, UI layout, state-machine transitions, request/response (§4.1). Each one is an abstraction in the Programming Paradigms layer, and ports are typed by them.
Projection. A read-only view a feature offers of its data, shaped for its readers, so they never read its struct. A technique for R10.
Push / pull. Whether the sender calls the receiver (push) or the receiver asks the sender (pull). Spray defaults to push because it works synchronously or asynchronously (§3.11.4).
Runner. A generic execution model that moves data between the instances of a composition value, so the application never touches it.
Silent contract. An agreement between two modules that appears in neither’s signature, such as a matching string, a tuple shape, or a session key (R5).
State abstraction. Spray’s State<T>: an abstraction with input and output ports that holds state belonging to no other concept, wired in like anything else (§3.9).
Symbolic connection. A name used only to connect two points in the code, like a local variable that carries a value between two calls. Fine inside one abstraction; across modules it becomes a registry of global names (§4.7.4, §7.23).
Tag. In the checklist’s notation, [thermo] marks a function that knows a product requirement, and [] marks a generic one. The one judgement the notation asks of a human.
Tramp parameter. A parameter a function never reads and only carries down to something further below. Spray: middle layers end up with “extra parameters that don’t have anything to do with them” (§3.11.1). R6’s “should”. The term itself is general programming usage, not Spray’s.
Wire. A run-time connection between two instances’ ports, set up by the layer above. Circular wiring is fine; circular knowledge dependencies are not.
Working chain. Product-knowing functions that do work and call each other, the shape of the bad thermometer. Each part should be either a real abstraction in a lower layer or wiring in the composition.
Zero coupling. No design-time knowledge between peers, not merely less of it. ALA removes bad dependencies rather than loosening them (§7.4).