• ascii only
• lowercase
• only essential parts
• avoid redundancy
• avoid excess abstraction

• one idea per sentence
• only subject-verb-object sentences
• no nested clauses
• avoid synonyms and idioms
• prefer declaratives or process actives
• avoid numbering in headings or lists, as it makes modification difficult

simply collect relevant words/keywords/vocabulary. build clusters of related concepts. identify transferable knowledge. structure notes as conceptual clusters with cleverly chosen category names.

labelling introduces discrete boundaries in the problem space. discretization permits combinatorial search, recombination, inference, and comparison. the manipulation of symbols, rather than undifferentiated experience, enables the detection of sameness, adjacency, and absence. it also supports compression of reasoning.

• create tuples of variables to map conceptual space.
• identify orthogonal primary variables {v₁, …, vₙ} spanning the conceptual space.
• for each variable, define orthogonal subvariables to refine coverage.
• incomplete vectors reveal missing dimensions; formulate questions that resolve them.

find the smallest high-leverage fact set that yields broad understanding. use a "20-questions" framing: each question carves the search space, reduces ambiguity, and links categories.

• extend only by increments that persist in the final system
• additions extend the shape already present, not correct or replace it
• represent unbuilt regions by identity or no-op boundaries, never provisional stand-ins
• consolidate only when multiple increments contain the same pattern and replacing those duplicates with a single shared component reduces overall complexity
• "even if it is not perfect, prepare it to become so"

computation viewed as a triplet: (input process output).

triplet reasoning treats each unit as a relation in which any two elements determine the third:

(input, transformation) -> output
(output, transformation) -> input
(input, output) -> transformation

this yields:

• representation: every component is defined by input, transformation, output
• inference: if two are known, derive the third
• diagnosis: if the third cannot be derived, the design is underspecified or discards information

therefore:

• the triplet pattern models functional evaluation directly
• completeness holds when evaluation is pure and referentially transparent
• failure of triplet closure indicates side effects, hidden state, or partial observability

in programming language design, the triplet describes the semantic core:

(expression, environment) -> value
(value, environment) -> expression  (only if representation is retained)

thus the same principle:

• where evaluation is reversible, structure is transparent
• where evaluation is not reversible, information was discarded

practical use:

• when integrating components, chain triplets by matching outputs to inputs
• when debugging or extending, reconstruct the missing element from the two available
• when this reconstruction fails, refine the representation until closure is restored

computation viewed as a duplet: (input output).

a duplet omits the internal process. only two questions remain:

• which inputs influence each output
• where each resulting value appears in the output structure

this yields a minimal observable model.

input -> output

• evaluate options against objectives, constraints, and trade-offs.
• document rationale and mark chosen paths

about the compact description of algorithms.

• mathematical notation using only ascii and function notation or english descriptions
• replace non-ascii glyphs, non-linear spatial layout with a linear ascii syntax and semantics

questions that can bring forth fundamental properties.

• "what is x always"
• "are there shared fundamentals between these two designs that could improve either"
• "does this application or usage expose flaws in the orthogonality of its parts"
• "what minimal set of primitives generates the observed variety"