LINGENIC-DESIGN-PRINCIPLES

# LINGENIC DESIGN PRINCIPLES
# Expressed in Lingenic notation.

# ═══════════════════════════════════════════════════════════════
# THE CORE QUESTIONS
# ═══════════════════════════════════════════════════════════════

core questions ≜ [
    question(what does this solve),
    question(do we have this problem),
    question(what is the simplest solution that works)
]

∀decision. requires(decision, core questions)

valid(decision) ↔ ∀q ∈ core questions. answerable(q) ∧ ¬appeals to(answer(q), {popularity, authority, convention})

# ═══════════════════════════════════════════════════════════════
# PRINCIPLE 1: SUBTRACTION OVER ADDITION
# ═══════════════════════════════════════════════════════════════

principle₁ ≜ subtraction ≻ addition ⟕ {src: shibui}

frame(design) ≜ removable(something) ∧ ¬addable(something)

easy(addition) ∧ requires(subtraction, judgment) ∧ judgment ≜ question(what is essential)

fastest(code) ≜ code(¬executes)
simplest(system) ≜ system(min(parts))
clearest(interface) ≜ interface(min(learning))

minimalism ≜ consequence ∧ ¬style

examples(principle₁) ≜ {
    (color(interface) ≜ one ∧ hierarchy ≜ opacity),
    (metadata ∈ filename ∧ ¬∃sidecar layer),
    (math typography ≜ monospace grid ∧ ¬∃rendering engine),
    (format ≜ one ∧ ¬∃conversion)
}

# ═══════════════════════════════════════════════════════════════
# PRINCIPLE 2: COMPLETENESS WITHIN DOMAIN
# ═══════════════════════════════════════════════════════════════

principle₂ ≜ ¬requires(work, leave(environment)) ⟕ {src: complete environment}

¬should be(user, integration layer(tools))
should contain(environment, requires(domain))

success(Excel) ∵ together({data, formulas, charts})
failure(alternative) ≜ edit(here) ; calculate(there) ; graph(elsewhere)

completeness ≜ domain specific
∴ (one tool(domain) ∧ ¬one tool(everything)) ⟕ {reason: coherence ∧ ¬scope creep}

cross(boundaries) ⟕ {mode: deliberate ∧ ¬constant}

examples(principle₂) ≜ {
    together(Compose, {document, computation, interaction}),
    together(filesystem, {storage, versioning, publishing}),
    together(typography, {design, build history, documentation})
}

# ═══════════════════════════════════════════════════════════════
# PRINCIPLE 3: UNDERSTANDING OVER IMITATION
# ═══════════════════════════════════════════════════════════════

principle₃ ≜ understanding ≻ imitation ⟕ {src: cargo cult software development}

cargo cult ≜ adoption ∧ ¬understanding

test(choice) ≜ explainable(choice, for(context)) ∧ ¬appeals to(explanation, {popularity, authority})

pass(test) → proceed
¬pass(test) → understand ; proceed

failure modes ≜ {
    (architectural ≜ distributed systems(single servers)),
    (process ≜ methodologies(different problems)),
    (tool ≜ technologies(different scales)),
    (vocabulary ≜ precise terms(as(empty buzzwords)))
}

opposite failure ≜ reject(X) ∵ popular(X)
contrarianism ≜ cargo cult(negative)

popularity ≜ ¬evidence(either way)
matters ≜ reasoning(context)

examples(principle₃) ≜ {
    (custom VCS ∵ ¬fits(git model)),
    (single color ∵ suffices(one variable)),
    (P4 phosphor ∵ historical accuracy ∧ ¬signaling),
    (monospace math ∵ ¬needed(rendering))
}

# ═══════════════════════════════════════════════════════════════
# PRINCIPLE 4: PORTABILITY THROUGH SIMPLICITY
# ═══════════════════════════════════════════════════════════════

principle₄ ≜ portability ← simplicity ⟕ {src: {lingenic naming spec, summation problem}}

survives(X, stupidest filesystem) → survives(X, everything)

survives(metadata in filenames, {any copy, any backup, any system})
survives(monospace math, {any editor, any font, any display})

sophisticated system ≜ fragile ∵ requires({compatible tools, correct configuration, unbroken chains})
simple system ≜ robust ∵ works({text files, filenames, monospace}, everywhere)

leave(native environment) → carries(simple representation, meaning)

examples(principle₄) ≜ {
    (naming convention ≜ readable(metadata) ∧ ¬requires(Lingenic tools)),
    (math notation ≜ readable ∧ ¬requires(TeX)),
    (file format ≜ parseable ∧ ¬requires(specialized software))
}

# ═══════════════════════════════════════════════════════════════
# THE UNIFICATION
# ═══════════════════════════════════════════════════════════════

¬separate({principle₁, principle₂, principle₃, principle₄})
unified ≜ facets(one stance)

subtraction → removes(unnecessary parts) → enables(completeness) ∵ fewer parts to integrate
subtraction → requires(understanding) ∵ must know(essential)
subtraction → produces(portability) ∵ less to carry

completeness → requires(subtraction) ∵ ¬include(everything)
completeness → requires(understanding) ∵ must know(domain boundary)
completeness → enables(portability) ∵ one thing to move

understanding → enables(subtraction) ∵ know(removable)
understanding → enables(completeness) ∵ know(stop point)
understanding → enables(portability) ∵ know(must survive)

portability → requires(subtraction) ∵ less to port
portability → requires(understanding) ∵ know(matters)
portability → enables(completeness) ∵ rebuildable(environment)

∀p ∈ principles. supports(p, others)
∃p. violated(p) → strained(all)

# ═══════════════════════════════════════════════════════════════
# THE AESTHETIC CONSEQUENCE
# ═══════════════════════════════════════════════════════════════

principles → aesthetic ⟕ {aesthetic: recognizable}

properties(aesthetic) ≜ {dark, high contrast, monospace, single color hierarchy, dense information, ¬decoration, ¬animation, ¬gradients, ¬shadows}

¬chosen(aesthetic, for(style))
aesthetic ≜ consequence(principles)

one color ← subtraction
visible(complete information) ← completeness
¬borrowed conventions ← understanding
works(any terminal) ← portability

aesthetic ≜ output ∧ ¬input

# ═══════════════════════════════════════════════════════════════
# THE ORGANIZATIONAL REQUIREMENT
# ═══════════════════════════════════════════════════════════════

difficult(sustain(principles))

¬built(feature) → ¬∃launch
prevented(work, by(engineer)) → ¬∃credit(engineer)

question(why ¬integrate(X))
question(why ¬support(format(Y)))

shipped(competitors, already)
question(why still(analyzing))

question(why plain text) ⟕ {objection: use(real database)}
question(why monospace) ⟕ {objection: use(real typography)}

rewards(organization, {visible output, fast shipping, broad compatibility, modern aesthetics}) → ¬sustains(organization, principles)

must reward(Lingenic, {prevented(work), depth(understanding), long term coherence})

rare(this) ∧ ¬capable(most organizations)

# ═══════════════════════════════════════════════════════════════
# THE TEST
# ═══════════════════════════════════════════════════════════════

∀decision: apply([test₁, test₂, test₃, test₄])

test₁ ≜ adds or removes(this) ∧ (adds(this) → necessary(addition))
test₂ ≜ fragments or unifies(this) ∧ (fragments(this) → correct(boundary))
test₃ ≜ explainable(this, ¬citing(others)) ∧ (¬explainable(this) → understands(I, this))
test₄ ≜ survives(this, outside(native environment)) ∧ (¬survives(this) → acceptable(that))

method ≜ four questions ∧ applied(honestly)

# ═══════════════════════════════════════════════════════════════
# THE RISK
# ═══════════════════════════════════════════════════════════════

◇becomes(principles, doctrine)

doctrine examples ≜ {
    (¬add(features) ∵ shibui),
    (¬integrate ∵ complete environment),
    (¬use(popular tools) ∵ cargo cult),
    (stay(primitive) ∵ portability)
}

becomes(principles, excuses) → ¬serves(principles)

test ≜ correct(choice, for(context))
test ≠ follows(choice, principle)

principles ≜ tools(thinking) ∧ ¬substitutes(thinking)

# ═══════════════════════════════════════════════════════════════
# SUMMARY
# ═══════════════════════════════════════════════════════════════

Lingenic philosophy ≜ {subtract(until(essential)), unify(within(domain)), understand(before(adopting)), simplify(for(portability))}

type(principles) ≜ questions ∧ ¬rules

applied(honestly, principles) → {small(systems), coherent(systems), reasoned(systems), survives(systems)}
¬applied(principles) → {grows(systems), fragments(systems), imitates(systems), depends(systems)}