From fe6ffd13ebbacd8421d9c77a214741c3f6ac49a8 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 10:09:32 +0200 Subject: [PATCH 01/12] wip --- _posts/2025-30-03-a-optimized-language.md | 69 ++++++++++ .../2025-30-03-a-optimized-language_notes.md | 123 ++++++++++++++++++ 2 files changed, 192 insertions(+) create mode 100644 _posts/2025-30-03-a-optimized-language.md create mode 100644 _posts/2025-30-03-a-optimized-language_notes.md diff --git a/_posts/2025-30-03-a-optimized-language.md b/_posts/2025-30-03-a-optimized-language.md new file mode 100644 index 0000000..5cb5356 --- /dev/null +++ b/_posts/2025-30-03-a-optimized-language.md @@ -0,0 +1,69 @@ +# A optimized languge + +-> focus on consonants +-> capitalization purely for emphasis, not a requirement +-> consistent pronounciation +-> we need more symbols why restrict us to abcd +-> different use of ;, =, -, *, ., +-> multiplicities +-> borrow concepts from programming +GOALS +-> faster input/output +-> better token efficiency +-> less redunndancy + +-> If we can read jumbled words and missing vocals, are they really necessary? + +https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia +https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6 +https://xkcd.com/1133/ + + + +Extract from my CLAUDE.md file: + +``` +## Communication Protocol + +Dense, compressed async pattern: + +**Symbols:** `✓` done | `→` next | `⨯` blocker | `?` clarify | `—` minimal punct + +**Flow:** You: short intent → Me: act → checkpoint → brief result → loop + +**Scope:** Assume cwd/git context. Surface blockers only. Iterate fast. +``` + +Communicating iwth CLaude I can disregard spelling, leave out letters without loosing on meaning/precision. +This shows that the english language is not optimized for communication, there is a lot of redudnacny. We can compress + + +Building on top of ./2026-03-28-map-reduce-myself.md + + +more formal definition + + +text example + +https://www.sciencedirect.com/science/article/pii/S0749596X23000967 +https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0281041#pone-0281041-t002 + + +My Gen-Z attention span iis very short. I want to get to the point FAST. +I want to go blazingly fast withotu loosing on rpecision + +-> new way to structure text. + + +-> markdown? pros/cons +-> latex? pros/cons +-> Uml + +A mode of expression that is optimized for communication + +excerpt from goethe + +inspration from gemtex markup + +expression via emojis and symbols diff --git a/_posts/2025-30-03-a-optimized-language_notes.md b/_posts/2025-30-03-a-optimized-language_notes.md new file mode 100644 index 0000000..88044aa --- /dev/null +++ b/_posts/2025-30-03-a-optimized-language_notes.md @@ -0,0 +1,123 @@ +# Notes: An Optimized Language + +I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? + +Building on "Map-Reducing Myself" * if we compressed 21MB of identity into 15 words, what does that say about the language we used for the other 20.99MB? + +## Thesis + +There is a spectrum from natural language to formal notation, and human-AI communication is carving out a new point on it. + +## Hieroglyphs as bookend + +Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: `join`, `pi`, `->`, emojis * reinventing hieroglyphs for specific domains. + +Arc: **hieroglyphs -> alphabets -> formal notation -> emoji/symbols -> compressed protocols** + +We started with symbols, detoured through words, and the optimal path forward might look more like where we began. + +## The language of the universe + +Math notation as the purest compressed language. Evolved over centuries toward maximum information density. + +Key nuance: math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses `sum_i x_i^2` instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. + +Upfront learning cost amortized over every future read. Same tradeoff as any compressed protocol. + +### Linear algebra as extreme case + +A single matrix multiplication `AB` encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. + +And it is the backbone of the AI we are communicating with. Nice circularity: the compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. + +### Relational algebra vs SQL + +`pi_name,email(R join S)` vs `SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id` + +21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is just redundancy the formal notation never needed. English-adjacent languages like SQL carry overhead that purer notations eliminate by design. + +## Programming languages: Ruby vs Java + +```ruby +users.select(&:active?).map(&:name) +``` + +```java +List names = users.stream() + .filter(User::isActive) + .map(User::getName) + .collect(Collectors.toList()); +``` + +Same logic. Java makes you declare `List`, wrap in `.stream()`, unwrap with `.collect(Collectors.toList())`. The type system demands you narrate what Ruby lets the reader infer from context. `names` already tells you it is a list of strings * the type annotation is redundant to anyone reading the code. + +The verbosity hides behind types vs naming. Java encodes meaning in the type system; Ruby encodes it in the name. Both work. One trusts context, the other spells it out. + +Spectrum: **Java -> Ruby -> math notation -> compressed protocol** + +## Typoglycaemia / redundancy + +If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. + +Links: +* https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia +* https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6 +* https://xkcd.com/1133/ +* https://www.sciencedirect.com/science/article/pii/S0749596X23000967 +* https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0281041#pone-0281041-t002 + +## The CLAUDE.md protocol as proof + +The strongest evidence is personal. The CLAUDE.md communication protocol: + +``` +Symbols: done | -> next | x blocker | ? clarify +Flow: short intent -> act -> checkpoint -> brief result -> loop +``` + +Communicating with Claude, spelling is irrelevant, vowels optional, grammar ignored * and precision is maintained. This proves English carries massive redundancy that can be stripped when both parties share enough context. + +Live example from this conversation: + +> "wt f w gt mr i dtl f xkcd" + +Decoded: "want/wait for * we get more in detail for/of xkcd" * a request to go deeper into the xkcd comic's actual content rather than just summarizing the concept. + +8 consonant-skeleton "words", no vowels, no grammar, fully understood. The message is 30 characters; the English version is 53. ~43% compression with zero loss of meaning. + +## Why I prefer talking to an LLM over humans + +LLMs are denser, more responsive, and work easier with loss. I can drop vowels, skip grammar, misspell everything, and the model still gets it. Humans need me to slow down, spell things out, repeat myself. The LLM meets me at my speed and my level of compression. It does not ask me to expand what I already said clearly enough. The bandwidth match is better. + +This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. The LLM just takes that one step further. + +Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. + +## The cost of ambiguity (personal) + +I struggle with emails. Every sentence carries the risk of misinterpretation. I do not want to sound hostile. I do not want to sound pushy. I do not want to be ambiguous. But English makes all three possible with the same words depending on how the reader feels that day. It is overwhelming. Same when talking to people * finding the right words, worrying about how they interpret me. Human language is lossy in the wrong direction: it does not lose redundancy, it loses intent. With an LLM I do not carry that weight. It does not read tone where there is none. + +## Ambiguity as the variable + +Formal notations compress because they strip ambiguity. English preserves ambiguity because human communication needs it. Human-AI communication needs less ambiguity than human-to-human but more than pure formal notation. The compressed protocol sits in that gap. + +## Open threads + +* Markdown/LaTeX/UML as prior art for structured text: pros/cons of each +* Goethe excerpt: find a passage that illustrates verbosity vs density +* GemTeX markup as inspiration +* Emojis and symbols as expression +* New way to structure text beyond paragraphs +* Consistent pronunciation, consonant focus, capitalization for emphasis only +* Multiplicities, borrowing concepts from programming (`;`, `=`, `*`, `*`, `.`) + +## Suggested structure + +1. Hook: you communicate with AI in broken English and it works perfectly. Why? +2. Hieroglyphs: we started with symbols, detoured through words +3. The universe speaks math: notation density, linear algebra, relational algebra vs SQL +4. Programming languages: Java vs Ruby, types vs naming +5. Evidence: typoglycaemia research, information density studies +6. The protocol: your CLAUDE.md as a working compressed language +7. The spectrum: natural language <-> formal notation, and where human-AI sits +8. Provocation: what would a language designed for this look like? From b4febe83be6af98468067eb079a562e1a17c8492 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 10:20:29 +0200 Subject: [PATCH 02/12] wip --- ....md => 2026-03-30-a-optimized-language.md} | 0 ... 2026-03-30-a-optimized-language_notes.md} | 31 +++++++++++++++++-- 2 files changed, 28 insertions(+), 3 deletions(-) rename _posts/{2025-30-03-a-optimized-language.md => 2026-03-30-a-optimized-language.md} (100%) rename _posts/{2025-30-03-a-optimized-language_notes.md => 2026-03-30-a-optimized-language_notes.md} (78%) diff --git a/_posts/2025-30-03-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md similarity index 100% rename from _posts/2025-30-03-a-optimized-language.md rename to _posts/2026-03-30-a-optimized-language.md diff --git a/_posts/2025-30-03-a-optimized-language_notes.md b/_posts/2026-03-30-a-optimized-language_notes.md similarity index 78% rename from _posts/2025-30-03-a-optimized-language_notes.md rename to _posts/2026-03-30-a-optimized-language_notes.md index 88044aa..0cca188 100644 --- a/_posts/2025-30-03-a-optimized-language_notes.md +++ b/_posts/2026-03-30-a-optimized-language_notes.md @@ -2,13 +2,15 @@ I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? +> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal + Building on "Map-Reducing Myself" * if we compressed 21MB of identity into 15 words, what does that say about the language we used for the other 20.99MB? ## Thesis There is a spectrum from natural language to formal notation, and human-AI communication is carving out a new point on it. -## Hieroglyphs as bookend +## Hieroglyphs as framing Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: `join`, `pi`, `->`, emojis * reinventing hieroglyphs for specific domains. @@ -59,6 +61,29 @@ Spectrum: **Java -> Ruby -> math notation -> compressed protocol** If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. +### xkcd 1133: Up Goer Five + +Randall Munroe describes the Saturn V rocket using only the 1000 most common English words. The results: + +* "The kind of air that once burned a big sky bag and people died" * hydrogen +* "This is full of that stuff they burned in lights before houses had power" * kerosene +* "Things holding that kind of air that makes your voice funny" * helium +* "Part that falls off first" / "Part that falls off second" / "Part that falls off third" * rocket stages + +27 annotations, averaging ~12 words each, to describe what an engineer conveys in 1-2 words per part. Roughly a 10x expansion. + +But there is a real tradeoff here. The Up Goer Five approach has advantages: + +* No upfront vocabulary to learn. Anyone who speaks English can read it. +* Smaller token set. You reuse the same 1000 common words, so the vocabulary overhead is near zero. +* Zero onboarding. A child can follow along. + +The cost: you need far more tokens per concept. "Hydrogen" is 1 word. "The kind of air that once burned a big sky bag and people died" is 14 words, and it is less precise * which sky bag? The Hindenburg, but you would never know. + +This is the fundamental tradeoff: **vocabulary size vs token count**. A large specialized vocabulary compresses each concept into fewer tokens but demands learning. A small vocabulary reuses tokens but requires more of them per concept. The optimal point depends on how many times you will reuse the vocabulary. For a one-time explanation: Up Goer Five wins. For daily communication: learn the word "hydrogen." + +Same tradeoff as the CLAUDE.md protocol. The upfront cost of agreeing on `->`, `x`, `?` is tiny. But it only pays off because we reuse those symbols hundreds of times. + Links: * https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia * https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6 @@ -91,7 +116,7 @@ LLMs are denser, more responsive, and work easier with loss. I can drop vowels, This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. The LLM just takes that one step further. -Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. +Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Consider composition vs aggregation in UML: a filled diamond explains lifetime-dependency in a single glyph. No sentence needed. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. ## The cost of ambiguity (personal) @@ -101,7 +126,7 @@ I struggle with emails. Every sentence carries the risk of misinterpretation. I Formal notations compress because they strip ambiguity. English preserves ambiguity because human communication needs it. Human-AI communication needs less ambiguity than human-to-human but more than pure formal notation. The compressed protocol sits in that gap. -## Open threads +## Additional ideas/thoughts * Markdown/LaTeX/UML as prior art for structured text: pros/cons of each * Goethe excerpt: find a passage that illustrates verbosity vs density From 3b6e3a38a309864b3d0c023f9dfa856bac0acee5 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 10:30:24 +0200 Subject: [PATCH 03/12] wip --- .gitignore | 3 + _config.yml | 1 + _layouts/base.html | 15 +++++ _plugins/latex_svg.rb | 65 +++++++++++++++++++ .../2026-03-30-a-optimized-language_notes.md | 41 ++++++++---- 5 files changed, 112 insertions(+), 13 deletions(-) create mode 100644 _plugins/latex_svg.rb diff --git a/.gitignore b/.gitignore index d1d00dd..88fe3f5 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,6 @@ vendor/ # jetbrains setting folder .idea/ + +# LaTeX build cache +.latex-cache/ diff --git a/_config.yml b/_config.yml index 854f438..2664735 100644 --- a/_config.yml +++ b/_config.yml @@ -39,3 +39,4 @@ exclude: - Gemfile.lock - bin/ - design.md + - .latex-cache/ diff --git a/_layouts/base.html b/_layouts/base.html index 71a89ce..7dbb0e8 100644 --- a/_layouts/base.html +++ b/_layouts/base.html @@ -79,6 +79,21 @@ pre { overflow-x: auto; } + + .latex-block { + text-align: center; + margin: 1em 0; + } + + .latex-block img, img.latex-inline { + vertical-align: middle; + } + + p img.latex-inline { + width: auto; + height: auto; + display: inline; + } diff --git a/_plugins/latex_svg.rb b/_plugins/latex_svg.rb new file mode 100644 index 0000000..25b3287 --- /dev/null +++ b/_plugins/latex_svg.rb @@ -0,0 +1,65 @@ +require "base64" +require "digest" +require "fileutils" +require "tempfile" + +module Jekyll + class LatexSvgTag < Liquid::Block + def initialize(tag_name, markup, tokens) + super + @display = markup.strip != "inline" + end + + def render(context) + latex = super.strip + cache_dir = File.join(context.registers[:site].source, ".latex-cache") + FileUtils.mkdir_p(cache_dir) + + hash = Digest::SHA256.hexdigest(latex)[0, 16] + svg_path = File.join(cache_dir, "#{hash}.svg") + + unless File.exist?(svg_path) + Dir.mktmpdir do |dir| + tex_file = File.join(dir, "input.tex") + File.write(tex_file, <<~TEX) + \\documentclass[preview]{standalone} + \\usepackage{amsmath} + \\usepackage{amssymb} + \\begin{document} + #{latex} + \\end{document} + TEX + + system("latex", "-interaction=nonstopmode", "-output-directory=#{dir}", tex_file, out: File::NULL, err: File::NULL) + dvi_file = File.join(dir, "input.dvi") + unless File.exist?(dvi_file) + Jekyll.logger.error "LaTeX:", "compilation failed for: #{latex[0, 60]}" + return "LaTeX error" + end + + system("dvisvgm", "--font-format=woff2", "--exact", dvi_file, "-o", svg_path, out: File::NULL, err: File::NULL) + unless File.exist?(svg_path) + Jekyll.logger.error "LaTeX:", "dvisvgm failed for: #{latex[0, 60]}" + return "SVG error" + end + end + end + + svg = File.read(svg_path) + svg = svg.sub(/<\?xml[^>]*\?>/, "").sub(//, "").strip + + width = svg[/width='([^']+)'/, 1] + height = svg[/height='([^']+)'/, 1] + encoded = Base64.strict_encode64(svg) + src = "data:image/svg+xml;base64,#{encoded}" + + if @display + %(\n
LaTeX
\n) + else + %(LaTeX) + end + end + end +end + +Liquid::Template.register_tag("latex", Jekyll::LatexSvgTag) diff --git a/_posts/2026-03-30-a-optimized-language_notes.md b/_posts/2026-03-30-a-optimized-language_notes.md index 0cca188..32ba78a 100644 --- a/_posts/2026-03-30-a-optimized-language_notes.md +++ b/_posts/2026-03-30-a-optimized-language_notes.md @@ -2,7 +2,7 @@ I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? -> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal +> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal [7] Building on "Map-Reducing Myself" * if we compressed 21MB of identity into 15 words, what does that say about the language we used for the other 20.99MB? @@ -12,7 +12,7 @@ There is a spectrum from natural language to formal notation, and human-AI commu ## Hieroglyphs as framing -Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: `join`, `pi`, `->`, emojis * reinventing hieroglyphs for specific domains. +Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: {% latex inline %}$\bowtie${% endlatex %}, {% latex inline %}$\pi${% endlatex %}, {% latex inline %}$\rightarrow${% endlatex %}, emojis * reinventing hieroglyphs for specific domains. Arc: **hieroglyphs -> alphabets -> formal notation -> emoji/symbols -> compressed protocols** @@ -22,19 +22,25 @@ We started with symbols, detoured through words, and the optimal path forward mi Math notation as the purest compressed language. Evolved over centuries toward maximum information density. -Key nuance: math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses `sum_i x_i^2` instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. +Key nuance: math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses {% latex inline %}$\sum_i x_i^2${% endlatex %} instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. Upfront learning cost amortized over every future read. Same tradeoff as any compressed protocol. ### Linear algebra as extreme case -A single matrix multiplication `AB` encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. +A single matrix multiplication {% latex inline %}$AB${% endlatex %} encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. And it is the backbone of the AI we are communicating with. Nice circularity: the compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. ### Relational algebra vs SQL -`pi_name,email(R join S)` vs `SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id` +{% latex %}\[\pi_{\text{name, email}}(R \bowtie S)\]{% endlatex %} + +vs + +```sql +SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id +``` 21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is just redundancy the formal notation never needed. English-adjacent languages like SQL carry overhead that purer notations eliminate by design. @@ -59,11 +65,11 @@ Spectrum: **Java -> Ruby -> math notation -> compressed protocol** ## Typoglycaemia / redundancy -If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. +If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) [1] proves English carries enough redundancy that large chunks can be dropped without losing meaning. Research on information density in communication supports this [2]. Cross-linguistic studies on word length [3] and word frequency effects across 12 alphabetic languages [4] further confirm the redundancy built into natural language. ### xkcd 1133: Up Goer Five -Randall Munroe describes the Saturn V rocket using only the 1000 most common English words. The results: +Randall Munroe describes the Saturn V rocket using only the 1000 most common English words [5]. The results: * "The kind of air that once burned a big sky bag and people died" * hydrogen * "This is full of that stuff they burned in lights before houses had power" * kerosene @@ -84,12 +90,21 @@ This is the fundamental tradeoff: **vocabulary size vs token count**. A large sp Same tradeoff as the CLAUDE.md protocol. The upfront cost of agreeing on `->`, `x`, `?` is tiny. But it only pays off because we reuse those symbols hundreds of times. -Links: -* https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia -* https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6 -* https://xkcd.com/1133/ -* https://www.sciencedirect.com/science/article/pii/S0749596X23000967 -* https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0281041#pone-0281041-t002 +## References + +[1] ScienceAlert, "The 'Cambridge' Word Jumble Meme Is More Complicated Than You Think," 2023. [Online]. Available: [https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) + +[2] S. Cordivano, "Better Communication: High Information Density," Medium, 2019. [Online]. Available: [https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) + +[3] S. Wichmann and E. W. Holman, "Cross-linguistic conditions on word length," PLOS ONE, vol. 18, no. 1, e0281041, Jan. 2023. [Online]. Available: [https://doi.org/10.1371/journal.pone.0281041](https://doi.org/10.1371/journal.pone.0281041) + +[4] V. Kuperman, S. Schroeder, and D. Gnetov, "Word length and frequency effects on text reading are highly similar in 12 alphabetic languages," Journal of Memory and Language, vol. 135, 104497, Feb. 2024. [Online]. Available: [https://doi.org/10.1016/j.jml.2023.104497](https://doi.org/10.1016/j.jml.2023.104497) + +[5] R. Munroe, "Up Goer Five," xkcd, no. 1133, 2012. [Online]. Available: [https://xkcd.com/1133/](https://xkcd.com/1133/) + +[6] R. Munroe, "Thing Explainer: Complicated Stuff in Simple Words." New York, NY, USA: Houghton Mifflin Harcourt, 2015. + +[7] B. Pascal, "Lettres Provinciales," letter XVI, 1657. ## The CLAUDE.md protocol as proof From 87c6d35f689580b1a7e5728ff3c98014b828a39d Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 10:36:32 +0200 Subject: [PATCH 04/12] wip --- _plugins/htmlbeautifier.rb | 2 ++ .../2026-03-30-a-optimized-language_notes.md | 27 +++++++------------ 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/_plugins/htmlbeautifier.rb b/_plugins/htmlbeautifier.rb index 83763f7..0921ea6 100644 --- a/_plugins/htmlbeautifier.rb +++ b/_plugins/htmlbeautifier.rb @@ -3,6 +3,8 @@ Jekyll::Hooks.register :site, :post_write do |site| Dir.glob(File.join(site.dest, "**", "*.html")).each do |file| source = File.read(file) + next if source.include?("latex-inline") || source.include?("latex-block") + beautified = HtmlBeautifier.beautify(source) File.write(file, beautified) end diff --git a/_posts/2026-03-30-a-optimized-language_notes.md b/_posts/2026-03-30-a-optimized-language_notes.md index 32ba78a..891c946 100644 --- a/_posts/2026-03-30-a-optimized-language_notes.md +++ b/_posts/2026-03-30-a-optimized-language_notes.md @@ -2,7 +2,7 @@ I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? -> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal [7] +> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal Building on "Map-Reducing Myself" * if we compressed 21MB of identity into 15 words, what does that say about the language we used for the other 20.99MB? @@ -65,11 +65,11 @@ Spectrum: **Java -> Ruby -> math notation -> compressed protocol** ## Typoglycaemia / redundancy -If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) [1] proves English carries enough redundancy that large chunks can be dropped without losing meaning. Research on information density in communication supports this [2]. Cross-linguistic studies on word length [3] and word frequency effects across 12 alphabetic languages [4] further confirm the redundancy built into natural language. +If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. ### xkcd 1133: Up Goer Five -Randall Munroe describes the Saturn V rocket using only the 1000 most common English words [5]. The results: +Randall Munroe describes the Saturn V rocket using only the 1000 most common English words. The results: * "The kind of air that once burned a big sky bag and people died" * hydrogen * "This is full of that stuff they burned in lights before houses had power" * kerosene @@ -90,21 +90,14 @@ This is the fundamental tradeoff: **vocabulary size vs token count**. A large sp Same tradeoff as the CLAUDE.md protocol. The upfront cost of agreeing on `->`, `x`, `?` is tiny. But it only pays off because we reuse those symbols hundreds of times. -## References +## Sources -[1] ScienceAlert, "The 'Cambridge' Word Jumble Meme Is More Complicated Than You Think," 2023. [Online]. Available: [https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) - -[2] S. Cordivano, "Better Communication: High Information Density," Medium, 2019. [Online]. Available: [https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) - -[3] S. Wichmann and E. W. Holman, "Cross-linguistic conditions on word length," PLOS ONE, vol. 18, no. 1, e0281041, Jan. 2023. [Online]. Available: [https://doi.org/10.1371/journal.pone.0281041](https://doi.org/10.1371/journal.pone.0281041) - -[4] V. Kuperman, S. Schroeder, and D. Gnetov, "Word length and frequency effects on text reading are highly similar in 12 alphabetic languages," Journal of Memory and Language, vol. 135, 104497, Feb. 2024. [Online]. Available: [https://doi.org/10.1016/j.jml.2023.104497](https://doi.org/10.1016/j.jml.2023.104497) - -[5] R. Munroe, "Up Goer Five," xkcd, no. 1133, 2012. [Online]. Available: [https://xkcd.com/1133/](https://xkcd.com/1133/) - -[6] R. Munroe, "Thing Explainer: Complicated Stuff in Simple Words." New York, NY, USA: Houghton Mifflin Harcourt, 2015. - -[7] B. Pascal, "Lettres Provinciales," letter XVI, 1657. +* [Typoglycaemia: The Cambridge Word Jumble](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) +* [Better Communication: High Information Density](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) +* [Cross-linguistic conditions on word length](https://doi.org/10.1371/journal.pone.0281041) +* [Word length and frequency effects across 12 alphabetic languages](https://doi.org/10.1016/j.jml.2023.104497) +* [xkcd 1133: Up Goer Five](https://xkcd.com/1133/) +* [Thing Explainer: Complicated Stuff in Simple Words](https://www.houghtonmifflinbooks.com/thingexplainer/) ## The CLAUDE.md protocol as proof From 81d71b9a57a6d07d68dd4b0c8c1e7da77a0f6d0c Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 12:52:32 +0200 Subject: [PATCH 05/12] Wip --- _posts/2026-03-30-a-optimized-language.md | 170 ++++++++++++++---- .../2026-03-30-a-optimized-language_notes.md | 156 ---------------- 2 files changed, 131 insertions(+), 195 deletions(-) delete mode 100644 _posts/2026-03-30-a-optimized-language_notes.md diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index 5cb5356..73facf6 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -1,69 +1,161 @@ -# A optimized languge +--- +title: "An Optimized Language" +date: 2026-03-30 +description: "English is bloated, math is dense, and the best language for talking to AI sits somewhere in between." +tags: ["language", "compression", "ai", "communication"] +--- --> focus on consonants --> capitalization purely for emphasis, not a requirement --> consistent pronounciation --> we need more symbols why restrict us to abcd --> different use of ;, =, -, *, ., --> multiplicities --> borrow concepts from programming -GOALS --> faster input/output --> better token efficiency --> less redunndancy +I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? --> If we can read jumbled words and missing vocals, are they really necessary? +> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal -https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia -https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6 -https://xkcd.com/1133/ +Building on ["Map-Reducing Myself"](http://localhost:4000/blog/map-reduce-myself/) * if we compressed 21MB of data into 15 words of identity, what does that say about the language we used for the other 20.99MB? +## Thesis +There is a spectrum from natural language to formal notation, and human-AI communication is carving out a new point on it. -Extract from my CLAUDE.md file: +## Hieroglyphs as framing +Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: {% latex inline %}$\bowtie${% endlatex %}, {% latex inline %}$\pi${% endlatex %}, {% latex inline %}$\rightarrow${% endlatex %}, emojis * reinventing hieroglyphs for specific domains. + +**hieroglyphs -> alphabets -> formal notation -> emoji/symbols -> compressed protocols** + +We started with symbols, detoured through words, and the optimal path forward might look more like where we began. + +## The language of the universe + +Math notation as the purest compressed language. Evolved over centuries toward maximum information density. + +Math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses {% latex inline %}$\sum_i x_i^2${% endlatex %} instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. + +Upfront learning cost amortized over every future read. Same tradeoff as any compressed protocol. + +### Linear algebra as extreme case + +A single matrix multiplication {% latex inline %}$AB${% endlatex %} encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. + +And it is the backbone of the AI we are communicating with. The compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. + +### Relational algebra vs SQL + +{% latex %}\[\pi_{\text{name, email}}(R \bowtie S)\]{% endlatex %} + +vs + +```sql +SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id +``` + +21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is just redundancy the formal notation never needed. English-adjacent languages like SQL carry overhead that purer notations eliminate by design. + +## Programming languages: Ruby vs Java + +```ruby +names = users.select(&:active?).map(&:name) +``` + +```java +List names = users.stream() + .filter(User::isActive) + .map(User::getName) + .collect(Collectors.toList()); ``` -## Communication Protocol -Dense, compressed async pattern: +Same logic. Java makes you declare `List`, wrap in `.stream()`, unwrap with `.collect(Collectors.toList())`. The type system demands you narrate what Ruby lets the reader infer from context. `names` already tells you it is a list of strings * the type annotation is redundant to anyone reading the code. -**Symbols:** `✓` done | `→` next | `⨯` blocker | `?` clarify | `—` minimal punct +The verbosity hides behind types vs naming. Java encodes meaning in the type system; Ruby encodes it in the name. Both work. One trusts context, the other spells it out. -**Flow:** You: short intent → Me: act → checkpoint → brief result → loop +**Java -> Ruby -> math notation -> compressed protocol** -**Scope:** Assume cwd/git context. Surface blockers only. Iterate fast. +## Typoglycaemia / redundancy + +If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. + +### xkcd 1133: Up Goer Five + +Randall Munroe describes the Saturn V rocket using only the 1000 most common English words. The results: + +* "The kind of air that once burned a big sky bag and people died" * hydrogen +* "This is full of that stuff they burned in lights before houses had power" * kerosene +* "Things holding that kind of air that makes your voice funny" * helium +* "Part that falls off first" / "Part that falls off second" / "Part that falls off third" * rocket stages + +27 annotations, averaging ~12 words each, to describe what an engineer conveys in 1-2 words per part. Roughly a 10x expansion. + +But there is a real tradeoff here. The Up Goer Five approach has advantages: + +* No upfront vocabulary to learn. Anyone who speaks English can read it. +* Smaller token set. You reuse the same 1000 common words, so the vocabulary overhead is near zero. +* Zero onboarding. A child can follow along. + +The cost: you need far more tokens per concept. "Hydrogen" is 1 word. "The kind of air that once burned a big sky bag and people died" is 14 words, and it is less precise * which sky bag? The Hindenburg, but you would never know. + +This is the fundamental tradeoff: **vocabulary size vs token count**. A large specialized vocabulary compresses each concept into fewer tokens but demands learning. A small vocabulary reuses tokens but requires more of them per concept. The optimal point depends on how many times you will reuse the vocabulary. For a one-time explanation: Up Goer Five wins. For daily communication: learn the word "hydrogen." + +Same tradeoff as the CLAUDE.md protocol. The upfront cost of agreeing on `->`, `x`, `?` is tiny. But it only pays off because we reuse those symbols hundreds of times. + + +## The CLAUDE.md protocol as proof + +The CLAUDE.md communication protocol: + +``` +Symbols: done | -> next | x blocker | ? clarify +Flow: short intent -> act -> checkpoint -> brief result -> loop ``` -Communicating iwth CLaude I can disregard spelling, leave out letters without loosing on meaning/precision. -This shows that the english language is not optimized for communication, there is a lot of redudnacny. We can compress +Communicating with Claude, spelling is irrelevant, vowels optional, grammar ignored * and precision is maintained. This proves English carries massive redundancy that can be stripped when both parties share enough context. + +Live example from this conversation: + +> "wt f w gt mr i dtl f xkcd" + +Decoded: "want/wait for * we get more in detail for/of xkcd" * a request to go deeper into the xkcd comic's actual content rather than just summarizing the concept. + +8 consonant-skeleton "words", no vowels, no grammar, fully understood. The message is 30 characters; the English version is 53. ~43% compression with zero loss of meaning. +## Why I prefer talking to an LLM over humans -Building on top of ./2026-03-28-map-reduce-myself.md +LLMs are denser, more responsive, and work easier with loss. I can drop vowels, skip grammar, misspell everything, and the model still gets it. Humans need me to slow down, spell things out, repeat myself. The LLM meets me at my speed and my level of compression. It does not ask me to expand what I already said clearly enough. The bandwidth match is better. +This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. For Software Engineering I enrolled in the English group so that the language stays as close to the technical side as possible. Having to live-translate an English class diagram into German for a presentation is overhead I want to minimize. Every translation is a lossy operation. The LLM just takes that one step further. -more formal definition +Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Consider composition vs aggregation in UML: a filled diamond explains lifetime-dependency in a single glyph. No sentence needed. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. +Same reason I use Neovim. It is the same principle applied to editing. In VS Code, reformatting a paragraph is: mouse select paragraph, open command palette, type "reflow", select the command. In Vim it is `gqap` * four keystrokes, no menu, no search. Select a word and uppercase it: `gUiw`. Delete everything inside quotes: `di"`. The grammar is composable: once you learn the verbs (`d`, `c`, `gU`, `gq`) and the nouns (`iw`, `ap`, `i"`), you can combine them without ever having seen the specific combination before. It is a compressed language for text manipulation. The upfront cost is steep, the long-term throughput is unmatched. -text example +## The cost of ambiguity (personal) -https://www.sciencedirect.com/science/article/pii/S0749596X23000967 -https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0281041#pone-0281041-t002 +I struggle with emails. Every sentence carries the risk of misinterpretation. I do not want to sound hostile. I do not want to sound pushy. I do not want to be ambiguous. But English makes all three possible with the same words depending on how the reader feels that day. It is overwhelming. Same when talking to people * finding the right words, worrying about how they interpret me. Human language is lossy in the wrong direction: it does not lose redundancy, it loses intent. With an LLM I do not carry that weight. It does not read tone where there is none. +## Ambiguity as the variable -My Gen-Z attention span iis very short. I want to get to the point FAST. -I want to go blazingly fast withotu loosing on rpecision +Formal notations compress because they strip ambiguity. English preserves ambiguity because human communication needs it. Human-AI communication needs less ambiguity than human-to-human but more than pure formal notation. The compressed protocol sits in that gap. --> new way to structure text. +## Rhythm and repetition +CGP Grey leans heavily into poetic structure in his narration. "Hexagons are the bestagons." It is not just a joke. Rhyme and rhythm improve memorization and flow. He repeats core concepts throughout a video, each time adding a layer, building cohesion. The repetition is not redundancy * it is reinforcement. The same phrase compressed into a catchphrase becomes a handle for the entire idea. --> markdown? pros/cons --> latex? pros/cons --> Uml +This is a different kind of compression. Not fewer tokens, but more memorable tokens. Poetry, slogans, mnemonics * they optimize for retrieval, not transmission. The best compressed language might need both: dense notation for writing, rhythmic structure for remembering. -A mode of expression that is optimized for communication +## Additional ideas/thoughts -excerpt from goethe +* Markdown/LaTeX/UML as prior art for structured text: pros/cons of each +* Goethe excerpt: find a passage that illustrates verbosity vs density +* GemTeX markup as inspiration +* Emojis and symbols as expression +* New way to structure text beyond paragraphs +* Consistent pronunciation, consonant focus, capitalization for emphasis only +* Multiplicities, borrowing concepts from programming (`;`, `=`, `*`, `*`, `.`) +* What if we communicate with LLMs via UML? -inspration from gemtex markup +## Sources -expression via emojis and symbols +* [Typoglycaemia: The Cambridge Word Jumble](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) +* [Better Communication: High Information Density](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) +* [Cross-linguistic conditions on word length](https://doi.org/10.1371/journal.pone.0281041) +* [Word length and frequency effects across 12 alphabetic languages](https://doi.org/10.1016/j.jml.2023.104497) +* [xkcd 1133: Up Goer Five](https://xkcd.com/1133/) +* [Thing Explainer: Complicated Stuff in Simple Words](https://www.houghtonmifflinbooks.com/thingexplainer/) +* [CGP Grey - Hexagons are the bestagons](https://www.youtube.com/watch?v=thOifuHs6eY) diff --git a/_posts/2026-03-30-a-optimized-language_notes.md b/_posts/2026-03-30-a-optimized-language_notes.md deleted file mode 100644 index 891c946..0000000 --- a/_posts/2026-03-30-a-optimized-language_notes.md +++ /dev/null @@ -1,156 +0,0 @@ -# Notes: An Optimized Language - -I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? - -> "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal - -Building on "Map-Reducing Myself" * if we compressed 21MB of identity into 15 words, what does that say about the language we used for the other 20.99MB? - -## Thesis - -There is a spectrum from natural language to formal notation, and human-AI communication is carving out a new point on it. - -## Hieroglyphs as framing - -Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: {% latex inline %}$\bowtie${% endlatex %}, {% latex inline %}$\pi${% endlatex %}, {% latex inline %}$\rightarrow${% endlatex %}, emojis * reinventing hieroglyphs for specific domains. - -Arc: **hieroglyphs -> alphabets -> formal notation -> emoji/symbols -> compressed protocols** - -We started with symbols, detoured through words, and the optimal path forward might look more like where we began. - -## The language of the universe - -Math notation as the purest compressed language. Evolved over centuries toward maximum information density. - -Key nuance: math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses {% latex inline %}$\sum_i x_i^2${% endlatex %} instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. - -Upfront learning cost amortized over every future read. Same tradeoff as any compressed protocol. - -### Linear algebra as extreme case - -A single matrix multiplication {% latex inline %}$AB${% endlatex %} encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. - -And it is the backbone of the AI we are communicating with. Nice circularity: the compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. - -### Relational algebra vs SQL - -{% latex %}\[\pi_{\text{name, email}}(R \bowtie S)\]{% endlatex %} - -vs - -```sql -SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id -``` - -21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is just redundancy the formal notation never needed. English-adjacent languages like SQL carry overhead that purer notations eliminate by design. - -## Programming languages: Ruby vs Java - -```ruby -users.select(&:active?).map(&:name) -``` - -```java -List names = users.stream() - .filter(User::isActive) - .map(User::getName) - .collect(Collectors.toList()); -``` - -Same logic. Java makes you declare `List`, wrap in `.stream()`, unwrap with `.collect(Collectors.toList())`. The type system demands you narrate what Ruby lets the reader infer from context. `names` already tells you it is a list of strings * the type annotation is redundant to anyone reading the code. - -The verbosity hides behind types vs naming. Java encodes meaning in the type system; Ruby encodes it in the name. Both work. One trusts context, the other spells it out. - -Spectrum: **Java -> Ruby -> math notation -> compressed protocol** - -## Typoglycaemia / redundancy - -If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. - -### xkcd 1133: Up Goer Five - -Randall Munroe describes the Saturn V rocket using only the 1000 most common English words. The results: - -* "The kind of air that once burned a big sky bag and people died" * hydrogen -* "This is full of that stuff they burned in lights before houses had power" * kerosene -* "Things holding that kind of air that makes your voice funny" * helium -* "Part that falls off first" / "Part that falls off second" / "Part that falls off third" * rocket stages - -27 annotations, averaging ~12 words each, to describe what an engineer conveys in 1-2 words per part. Roughly a 10x expansion. - -But there is a real tradeoff here. The Up Goer Five approach has advantages: - -* No upfront vocabulary to learn. Anyone who speaks English can read it. -* Smaller token set. You reuse the same 1000 common words, so the vocabulary overhead is near zero. -* Zero onboarding. A child can follow along. - -The cost: you need far more tokens per concept. "Hydrogen" is 1 word. "The kind of air that once burned a big sky bag and people died" is 14 words, and it is less precise * which sky bag? The Hindenburg, but you would never know. - -This is the fundamental tradeoff: **vocabulary size vs token count**. A large specialized vocabulary compresses each concept into fewer tokens but demands learning. A small vocabulary reuses tokens but requires more of them per concept. The optimal point depends on how many times you will reuse the vocabulary. For a one-time explanation: Up Goer Five wins. For daily communication: learn the word "hydrogen." - -Same tradeoff as the CLAUDE.md protocol. The upfront cost of agreeing on `->`, `x`, `?` is tiny. But it only pays off because we reuse those symbols hundreds of times. - -## Sources - -* [Typoglycaemia: The Cambridge Word Jumble](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) -* [Better Communication: High Information Density](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) -* [Cross-linguistic conditions on word length](https://doi.org/10.1371/journal.pone.0281041) -* [Word length and frequency effects across 12 alphabetic languages](https://doi.org/10.1016/j.jml.2023.104497) -* [xkcd 1133: Up Goer Five](https://xkcd.com/1133/) -* [Thing Explainer: Complicated Stuff in Simple Words](https://www.houghtonmifflinbooks.com/thingexplainer/) - -## The CLAUDE.md protocol as proof - -The strongest evidence is personal. The CLAUDE.md communication protocol: - -``` -Symbols: done | -> next | x blocker | ? clarify -Flow: short intent -> act -> checkpoint -> brief result -> loop -``` - -Communicating with Claude, spelling is irrelevant, vowels optional, grammar ignored * and precision is maintained. This proves English carries massive redundancy that can be stripped when both parties share enough context. - -Live example from this conversation: - -> "wt f w gt mr i dtl f xkcd" - -Decoded: "want/wait for * we get more in detail for/of xkcd" * a request to go deeper into the xkcd comic's actual content rather than just summarizing the concept. - -8 consonant-skeleton "words", no vowels, no grammar, fully understood. The message is 30 characters; the English version is 53. ~43% compression with zero loss of meaning. - -## Why I prefer talking to an LLM over humans - -LLMs are denser, more responsive, and work easier with loss. I can drop vowels, skip grammar, misspell everything, and the model still gets it. Humans need me to slow down, spell things out, repeat myself. The LLM meets me at my speed and my level of compression. It does not ask me to expand what I already said clearly enough. The bandwidth match is better. - -This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. The LLM just takes that one step further. - -Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Consider composition vs aggregation in UML: a filled diamond explains lifetime-dependency in a single glyph. No sentence needed. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. - -## The cost of ambiguity (personal) - -I struggle with emails. Every sentence carries the risk of misinterpretation. I do not want to sound hostile. I do not want to sound pushy. I do not want to be ambiguous. But English makes all three possible with the same words depending on how the reader feels that day. It is overwhelming. Same when talking to people * finding the right words, worrying about how they interpret me. Human language is lossy in the wrong direction: it does not lose redundancy, it loses intent. With an LLM I do not carry that weight. It does not read tone where there is none. - -## Ambiguity as the variable - -Formal notations compress because they strip ambiguity. English preserves ambiguity because human communication needs it. Human-AI communication needs less ambiguity than human-to-human but more than pure formal notation. The compressed protocol sits in that gap. - -## Additional ideas/thoughts - -* Markdown/LaTeX/UML as prior art for structured text: pros/cons of each -* Goethe excerpt: find a passage that illustrates verbosity vs density -* GemTeX markup as inspiration -* Emojis and symbols as expression -* New way to structure text beyond paragraphs -* Consistent pronunciation, consonant focus, capitalization for emphasis only -* Multiplicities, borrowing concepts from programming (`;`, `=`, `*`, `*`, `.`) - -## Suggested structure - -1. Hook: you communicate with AI in broken English and it works perfectly. Why? -2. Hieroglyphs: we started with symbols, detoured through words -3. The universe speaks math: notation density, linear algebra, relational algebra vs SQL -4. Programming languages: Java vs Ruby, types vs naming -5. Evidence: typoglycaemia research, information density studies -6. The protocol: your CLAUDE.md as a working compressed language -7. The spectrum: natural language <-> formal notation, and where human-AI sits -8. Provocation: what would a language designed for this look like? From 9a6b40a090216d9fd5b648a70bba542f21a1abea Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 13:43:00 +0200 Subject: [PATCH 06/12] wip --- _posts/2026-03-30-a-optimized-language.md | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index 73facf6..6c500ee 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -3,21 +3,26 @@ title: "An Optimized Language" date: 2026-03-30 description: "English is bloated, math is dense, and the best language for talking to AI sits somewhere in between." tags: ["language", "compression", "ai", "communication"] +math: true --- I communicate with AI in broken English and it works perfectly. I drop vowels, ignore spelling, skip grammar, and the meaning arrives intact. Why? > "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal -Building on ["Map-Reducing Myself"](http://localhost:4000/blog/map-reduce-myself/) * if we compressed 21MB of data into 15 words of identity, what does that say about the language we used for the other 20.99MB? +Building on ["Map-Reducing Myself"](blog/map-reduce-myself/) * if we compressed 21MB of data into 15 words of identity, what does that say about the language we used for the other 20.99MB? ## Thesis There is a spectrum from natural language to formal notation, and human-AI communication is carving out a new point on it. +$$\text{Communication efficiency} = f(\text{token count}, \text{ambiguity}, \text{vocabulary size}, \text{decoding cost})$$ + +Every example in this article is a tradeoff between these four variables. + ## Hieroglyphs as framing -Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: {% latex inline %}$\bowtie${% endlatex %}, {% latex inline %}$\pi${% endlatex %}, {% latex inline %}$\rightarrow${% endlatex %}, emojis * reinventing hieroglyphs for specific domains. +Hieroglyphs were logographic: one symbol encoded an entire concept. We decomposed that into alphabets (phonetic atoms), gained universal composability but lost density. Now we are circling back: $\bowtie$, $\pi$, $\rightarrow$, emojis * reinventing hieroglyphs for specific domains. **hieroglyphs -> alphabets -> formal notation -> emoji/symbols -> compressed protocols** @@ -27,19 +32,19 @@ We started with symbols, detoured through words, and the optimal path forward mi Math notation as the purest compressed language. Evolved over centuries toward maximum information density. -Math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses {% latex inline %}$\sum_i x_i^2${% endlatex %} instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. +Math symbols are not faster to write (typing `integral`, `sum`, `join` is awkward) but massively faster to read. A trained eye parses $\sum_i x_i^2$ instantly; "the sum of the squares of each element x sub i" requires linear reading. Optimized for output bandwidth, not input. Upfront learning cost amortized over every future read. Same tradeoff as any compressed protocol. ### Linear algebra as extreme case -A single matrix multiplication {% latex inline %}$AB${% endlatex %} encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. +A single matrix multiplication $AB$ encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. And it is the backbone of the AI we are communicating with. The compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. ### Relational algebra vs SQL -{% latex %}\[\pi_{\text{name, email}}(R \bowtie S)\]{% endlatex %} +$$\pi_{\text{name, email}}(R \bowtie S)$$ vs @@ -150,6 +155,10 @@ This is a different kind of compression. Not fewer tokens, but more memorable to * Multiplicities, borrowing concepts from programming (`;`, `=`, `*`, `*`, `.`) * What if we communicate with LLMs via UML? +## Claude the writer, me the editor + +Every section in this article started as a compressed prompt and went through multiple rounds of editing. Claude drafted, I rejected, corrected, restructured, added context only I had. "wt f w gt mr i dtl f xkcd" became the Up Goer Five analysis. "mention math symbols maybe not faster to write but much faster to read" became the information density argument. The ideas and the direction were mine. The expansion was collaborative. The process was the proof. + ## Sources * [Typoglycaemia: The Cambridge Word Jumble](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) From d8fa009a0573656835cd51ca600b37cb311a1a7f Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 13:49:41 +0200 Subject: [PATCH 07/12] wip --- _posts/2026-03-30-a-optimized-language.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index 6c500ee..67debc8 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -157,7 +157,7 @@ This is a different kind of compression. Not fewer tokens, but more memorable to ## Claude the writer, me the editor -Every section in this article started as a compressed prompt and went through multiple rounds of editing. Claude drafted, I rejected, corrected, restructured, added context only I had. "wt f w gt mr i dtl f xkcd" became the Up Goer Five analysis. "mention math symbols maybe not faster to write but much faster to read" became the information density argument. The ideas and the direction were mine. The expansion was collaborative. The process was the proof. +Every section in this article started as a compressed prompt and went through multiple rounds of editing. Claude drafted, I rejected, corrected, restructured, added context only I had. "wt f w gt mr i dtl f xkcd" became the Up Goer Five analysis. "mntn mth symbols mb not faster write but much faster read" became the information density argument. The ideas and the direction were mine. The expansion was collaborative. The process was the proof. ## Sources From bbb78360ad54b1ec049c68420a099d87b2b176a4 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 13:55:20 +0200 Subject: [PATCH 08/12] Rephrase --- _posts/2026-03-30-a-optimized-language.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index 67debc8..29182ce 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -18,7 +18,7 @@ There is a spectrum from natural language to formal notation, and human-AI commu $$\text{Communication efficiency} = f(\text{token count}, \text{ambiguity}, \text{vocabulary size}, \text{decoding cost})$$ -Every example in this article is a tradeoff between these four variables. +Every example in this article is a tradeoff between these four variables. The key constraint: density scales with shared context. Compression only works because both sides share the same priors. ## Hieroglyphs as framing @@ -38,7 +38,7 @@ Upfront learning cost amortized over every future read. Same tradeoff as any com ### Linear algebra as extreme case -A single matrix multiplication $AB$ encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. +A single matrix multiplication $AB$ encodes potentially millions of operations. Two characters, behind them a thousand nested loops. No natural language comes close to that compression ratio. This is not just compression * it is delegation to a shared semantic model. $AB$ only works because both sides agree on what matrix multiplication means. Compression requires a shared decoding function. And it is the backbone of the AI we are communicating with. The compressed language (linear algebra) built the system (neural nets) that now lets you use another compressed language (your protocol) to talk to it. @@ -52,7 +52,7 @@ vs SELECT DISTINCT name, email FROM R INNER JOIN S ON R.id = S.id ``` -21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is just redundancy the formal notation never needed. English-adjacent languages like SQL carry overhead that purer notations eliminate by design. +21 chars vs 67. The algebra implies distinctness (set-based by definition), so DISTINCT is redundancy the formal notation never needed. SQL trades density for explicitness and practical execution semantics: bag semantics, execution hints, readability for broader audiences. The verbosity is not accidental. But for expressing the pure relational operation, the algebra is unmatched. ## Programming languages: Ruby vs Java @@ -69,13 +69,13 @@ List names = users.stream() Same logic. Java makes you declare `List`, wrap in `.stream()`, unwrap with `.collect(Collectors.toList())`. The type system demands you narrate what Ruby lets the reader infer from context. `names` already tells you it is a list of strings * the type annotation is redundant to anyone reading the code. -The verbosity hides behind types vs naming. Java encodes meaning in the type system; Ruby encodes it in the name. Both work. One trusts context, the other spells it out. +Java encodes constraints and guarantees. Ruby encodes intent and convention. Both work. One trusts context, the other spells it out. **Java -> Ruby -> math notation -> compressed protocol** ## Typoglycaemia / redundancy -If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. +Shannon entropy tells us that natural language carries far more bits per symbol than the minimum needed to convey meaning. If we can read jumbled words and sentences with missing vowels, are they really necessary? The Cambridge meme (first/last letter preservation) proves English carries enough redundancy that large chunks can be dropped without losing meaning. ### xkcd 1133: Up Goer Five @@ -118,11 +118,11 @@ Live example from this conversation: Decoded: "want/wait for * we get more in detail for/of xkcd" * a request to go deeper into the xkcd comic's actual content rather than just summarizing the concept. -8 consonant-skeleton "words", no vowels, no grammar, fully understood. The message is 30 characters; the English version is 53. ~43% compression with zero loss of meaning. +8 consonant-skeleton "words", no vowels, no grammar, fully understood. The message is 30 characters; the English version is 53. ~43% compression with low perceived loss under shared context. ## Why I prefer talking to an LLM over humans -LLMs are denser, more responsive, and work easier with loss. I can drop vowels, skip grammar, misspell everything, and the model still gets it. Humans need me to slow down, spell things out, repeat myself. The LLM meets me at my speed and my level of compression. It does not ask me to expand what I already said clearly enough. The bandwidth match is better. +LLMs optimize for throughput. Humans optimize for alignment. LLMs are denser, more responsive, and work easier with loss. I can drop vowels, skip grammar, misspell everything, and the model still gets it. Humans need me to slow down, spell things out, repeat myself. The LLM meets me at my speed and my level of compression. It does not ask me to expand what I already said clearly enough. The bandwidth match is better. This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. For Software Engineering I enrolled in the English group so that the language stays as close to the technical side as possible. Having to live-translate an English class diagram into German for a presentation is overhead I want to minimize. Every translation is a lossy operation. The LLM just takes that one step further. From 180a49c294f96f54807f88ba251f6d6c6527d586 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 14:07:45 +0200 Subject: [PATCH 09/12] wip --- .gitignore | 3 -- _config.yml | 1 - _layouts/base.html | 19 ++----- _plugins/htmlbeautifier.rb | 2 - _plugins/latex_svg.rb | 65 ----------------------- _posts/2026-03-30-a-optimized-language.md | 11 ++-- 6 files changed, 11 insertions(+), 90 deletions(-) delete mode 100644 _plugins/latex_svg.rb diff --git a/.gitignore b/.gitignore index 88fe3f5..d1d00dd 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,3 @@ vendor/ # jetbrains setting folder .idea/ - -# LaTeX build cache -.latex-cache/ diff --git a/_config.yml b/_config.yml index 2664735..854f438 100644 --- a/_config.yml +++ b/_config.yml @@ -39,4 +39,3 @@ exclude: - Gemfile.lock - bin/ - design.md - - .latex-cache/ diff --git a/_layouts/base.html b/_layouts/base.html index 7dbb0e8..ec8de5a 100644 --- a/_layouts/base.html +++ b/_layouts/base.html @@ -80,21 +80,12 @@ overflow-x: auto; } - .latex-block { - text-align: center; - margin: 1em 0; - } - - .latex-block img, img.latex-inline { - vertical-align: middle; - } - - p img.latex-inline { - width: auto; - height: auto; - display: inline; - } + {%- if page.math -%} + + + + {%- endif -%}
diff --git a/_plugins/htmlbeautifier.rb b/_plugins/htmlbeautifier.rb index 0921ea6..83763f7 100644 --- a/_plugins/htmlbeautifier.rb +++ b/_plugins/htmlbeautifier.rb @@ -3,8 +3,6 @@ Jekyll::Hooks.register :site, :post_write do |site| Dir.glob(File.join(site.dest, "**", "*.html")).each do |file| source = File.read(file) - next if source.include?("latex-inline") || source.include?("latex-block") - beautified = HtmlBeautifier.beautify(source) File.write(file, beautified) end diff --git a/_plugins/latex_svg.rb b/_plugins/latex_svg.rb deleted file mode 100644 index 25b3287..0000000 --- a/_plugins/latex_svg.rb +++ /dev/null @@ -1,65 +0,0 @@ -require "base64" -require "digest" -require "fileutils" -require "tempfile" - -module Jekyll - class LatexSvgTag < Liquid::Block - def initialize(tag_name, markup, tokens) - super - @display = markup.strip != "inline" - end - - def render(context) - latex = super.strip - cache_dir = File.join(context.registers[:site].source, ".latex-cache") - FileUtils.mkdir_p(cache_dir) - - hash = Digest::SHA256.hexdigest(latex)[0, 16] - svg_path = File.join(cache_dir, "#{hash}.svg") - - unless File.exist?(svg_path) - Dir.mktmpdir do |dir| - tex_file = File.join(dir, "input.tex") - File.write(tex_file, <<~TEX) - \\documentclass[preview]{standalone} - \\usepackage{amsmath} - \\usepackage{amssymb} - \\begin{document} - #{latex} - \\end{document} - TEX - - system("latex", "-interaction=nonstopmode", "-output-directory=#{dir}", tex_file, out: File::NULL, err: File::NULL) - dvi_file = File.join(dir, "input.dvi") - unless File.exist?(dvi_file) - Jekyll.logger.error "LaTeX:", "compilation failed for: #{latex[0, 60]}" - return "LaTeX error" - end - - system("dvisvgm", "--font-format=woff2", "--exact", dvi_file, "-o", svg_path, out: File::NULL, err: File::NULL) - unless File.exist?(svg_path) - Jekyll.logger.error "LaTeX:", "dvisvgm failed for: #{latex[0, 60]}" - return "SVG error" - end - end - end - - svg = File.read(svg_path) - svg = svg.sub(/<\?xml[^>]*\?>/, "").sub(//, "").strip - - width = svg[/width='([^']+)'/, 1] - height = svg[/height='([^']+)'/, 1] - encoded = Base64.strict_encode64(svg) - src = "data:image/svg+xml;base64,#{encoded}" - - if @display - %(\n
LaTeX
\n) - else - %(LaTeX) - end - end - end -end - -Liquid::Template.register_tag("latex", Jekyll::LatexSvgTag) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index 29182ce..b8f0d2e 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -18,7 +18,7 @@ There is a spectrum from natural language to formal notation, and human-AI commu $$\text{Communication efficiency} = f(\text{token count}, \text{ambiguity}, \text{vocabulary size}, \text{decoding cost})$$ -Every example in this article is a tradeoff between these four variables. The key constraint: density scales with shared context. Compression only works because both sides share the same priors. +Every example in this article is a tradeoff between these four variables. The key constraint: density scales with shared context. Compression only works because both sides share the same context. ## Hieroglyphs as framing @@ -126,9 +126,9 @@ LLMs optimize for throughput. Humans optimize for alignment. LLMs are denser, mo This is not a social preference. It is a communication efficiency preference. I already optimize across languages in daily life: my sister and I both speak fluent Czech, but we write to each other in English. It is more token efficient. Simpler. No need to differentiate i/y. No carets, no accents. Shorter words. I do the same with classmates who are native German speakers * we default to English because it is faster. You can rush more, compress more, and still land the meaning. For Software Engineering I enrolled in the English group so that the language stays as close to the technical side as possible. Having to live-translate an English class diagram into German for a presentation is overhead I want to minimize. Every translation is a lossy operation. The LLM just takes that one step further. -Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. Exception: I like UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Consider composition vs aggregation in UML: a filled diamond explains lifetime-dependency in a single glyph. No sentence needed. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. +Same pattern in what I enjoy studying at ZHAW. I like Analysis 1, Analysis 2, Linear Algebra, Information Theory. These are not ambiguous. They are precise. There is one correct answer. I do not like Databases or Communication modules. Those are imprecise, ambiguous, require more context. Domain modeling is not a precise task * it depends on interpretation, convention, stakeholder opinions. The modules I gravitate toward are the ones where the language is already compressed and unambiguous. The part of Software Engineering I do like is UML. It allows me to express myself very compactly. First you define the communication protocol * the notation itself. Then you can communicate concepts in a very efficient manner. The upfront cost of agreeing on the symbols pays off in every diagram after. Consider composition vs aggregation in UML: a filled diamond explains lifetime-dependency in a single glyph. No sentence needed. Same principle as math notation, same principle as the CLAUDE.md protocol. The same message that takes 8 consonant skeletons with Claude would need a full paragraph with a person, plus clarification, plus context setting. The protocol overhead of human communication is massive. -Same reason I use Neovim. It is the same principle applied to editing. In VS Code, reformatting a paragraph is: mouse select paragraph, open command palette, type "reflow", select the command. In Vim it is `gqap` * four keystrokes, no menu, no search. Select a word and uppercase it: `gUiw`. Delete everything inside quotes: `di"`. The grammar is composable: once you learn the verbs (`d`, `c`, `gU`, `gq`) and the nouns (`iw`, `ap`, `i"`), you can combine them without ever having seen the specific combination before. It is a compressed language for text manipulation. The upfront cost is steep, the long-term throughput is unmatched. +Same reason I use Neovim. It is the same principle applied to editing. In VS Code, reformatting a paragraph is: mouse select paragraph, open command palette, type "reflow", select the command. In Vim it is `gqap` * four keystrokes, no menu, no search. Select a word and uppercase it: `gUiw`. Delete everything inside quotes: `di"`. The grammar is composable: once you learn the verbs (`d`, `c`, `gU`, `gq`) and the nouns (`iw`, `ap`, `i"`), you can combine them without ever having seen the specific combination before. It is a compressed language for text manipulation. The upfront cost is steep, the long-term throughput unmatched. ## The cost of ambiguity (personal) @@ -148,7 +148,7 @@ This is a different kind of compression. Not fewer tokens, but more memorable to * Markdown/LaTeX/UML as prior art for structured text: pros/cons of each * Goethe excerpt: find a passage that illustrates verbosity vs density -* GemTeX markup as inspiration +* GEMTEX markup as inspiration * Emojis and symbols as expression * New way to structure text beyond paragraphs * Consistent pronunciation, consonant focus, capitalization for emphasis only @@ -157,7 +157,7 @@ This is a different kind of compression. Not fewer tokens, but more memorable to ## Claude the writer, me the editor -Every section in this article started as a compressed prompt and went through multiple rounds of editing. Claude drafted, I rejected, corrected, restructured, added context only I had. "wt f w gt mr i dtl f xkcd" became the Up Goer Five analysis. "mntn mth symbols mb not faster write but much faster read" became the information density argument. The ideas and the direction were mine. The expansion was collaborative. The process was the proof. +Every section in this article started as a compressed prompt and went through multiple rounds of editing. Claude drafted, I rejected, corrected, restructured, added context only I had. "wt f w gt mr i dtl f xkcd" became the Up Goer Five analysis. "mntn mth symbols mb not faster write but mch faster read" became the information density argument. The ideas and the direction were mine. The expansion was collaborative. The process was the proof. ## Sources @@ -168,3 +168,4 @@ Every section in this article started as a compressed prompt and went through mu * [xkcd 1133: Up Goer Five](https://xkcd.com/1133/) * [Thing Explainer: Complicated Stuff in Simple Words](https://www.houghtonmifflinbooks.com/thingexplainer/) * [CGP Grey - Hexagons are the bestagons](https://www.youtube.com/watch?v=thOifuHs6eY) +* [Introduction to GEMTEXT](https://lionwiki-t2t.sourceforge.io/gemtext.html) From aa5db8633129fbc04cdb887e49826500c7e6b75c Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 14:13:06 +0200 Subject: [PATCH 10/12] L --- _posts/2026-03-30-a-optimized-language.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index b8f0d2e..e115e4b 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -10,7 +10,7 @@ I communicate with AI in broken English and it works perfectly. I drop vowels, i > "I have made this longer than usual because I have not had time to make it shorter." * Blaise Pascal -Building on ["Map-Reducing Myself"](blog/map-reduce-myself/) * if we compressed 21MB of data into 15 words of identity, what does that say about the language we used for the other 20.99MB? +Building on ["Map-Reducing Myself"](/blog/map-reduce-myself/) * if we compressed 21MB of data into 15 words of identity, what does that say about the language we used for the other 20.99MB? ## Thesis @@ -162,10 +162,10 @@ Every section in this article started as a compressed prompt and went through mu ## Sources * [Typoglycaemia: The Cambridge Word Jumble](https://www.sciencealert.com/word-jumble-meme-first-last-letters-cambridge-typoglycaemia) -* [Better Communication: High Information Density](https://medium.com/sarah-cordivano/better-communication-high-information-density-662fe8bfa8d6) +* [Better Communication: High Information Density](https://sarahcordivano.medium.com/better-communication-high-information-density-662fe8bfa8d6) * [Cross-linguistic conditions on word length](https://doi.org/10.1371/journal.pone.0281041) * [Word length and frequency effects across 12 alphabetic languages](https://doi.org/10.1016/j.jml.2023.104497) * [xkcd 1133: Up Goer Five](https://xkcd.com/1133/) -* [Thing Explainer: Complicated Stuff in Simple Words](https://www.houghtonmifflinbooks.com/thingexplainer/) +* [Thing Explainer: Complicated Stuff in Simple Words](https://en.wikipedia.org/wiki/Thing_Explainer) * [CGP Grey - Hexagons are the bestagons](https://www.youtube.com/watch?v=thOifuHs6eY) * [Introduction to GEMTEXT](https://lionwiki-t2t.sourceforge.io/gemtext.html) From 1422ce5389c8991557035852a021169c48195235 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 14:59:46 +0200 Subject: [PATCH 11/12] Remove proofer because it is flakey --- .github/workflows/ci.yml | 1 - Gemfile | 1 - Gemfile.lock | 68 ---------------------------------------- README.md | 8 ----- bin/htmlproofer | 14 --------- 5 files changed, 92 deletions(-) delete mode 100755 bin/htmlproofer diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 642d4a8..329b89d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,4 +16,3 @@ jobs: bundler-cache: true - run: bin/check_unicode - run: bundle exec jekyll build - - run: bin/htmlproofer diff --git a/Gemfile b/Gemfile index 41a4f30..e10c313 100644 --- a/Gemfile +++ b/Gemfile @@ -1,7 +1,6 @@ source "https://rubygems.org" gem "jekyll", "~> 4.3" -gem "html-proofer" gem "htmlbeautifier" gem "fastimage" diff --git a/Gemfile.lock b/Gemfile.lock index 5fd5e53..e246aef 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -1,31 +1,16 @@ GEM remote: https://rubygems.org/ specs: - Ascii85 (2.0.1) addressable (2.8.8) public_suffix (>= 2.0.2, < 8.0) - afm (1.0.0) - async (2.36.0) - console (~> 1.29) - fiber-annotation - io-event (~> 1.11) - metrics (~> 0.12) - traces (~> 0.18) base64 (0.3.0) - benchmark (0.5.0) bigdecimal (4.0.1) colorator (1.1.0) concurrent-ruby (1.3.6) - console (1.34.3) - fiber-annotation - fiber-local (~> 1.1) - json csv (3.3.5) em-websocket (0.5.3) eventmachine (>= 0.12.9) http_parser.rb (~> 0) - ethon (0.15.0) - ffi (>= 1.15.0) eventmachine (1.2.7) fastimage (2.4.0) ffi (1.17.3) @@ -39,10 +24,6 @@ GEM ffi (1.17.3-x86_64-darwin) ffi (1.17.3-x86_64-linux-gnu) ffi (1.17.3-x86_64-linux-musl) - fiber-annotation (0.2.0) - fiber-local (1.1.0) - fiber-storage - fiber-storage (1.0.1) forwardable-extended (2.6.0) google-protobuf (4.33.5) bigdecimal @@ -71,22 +52,10 @@ GEM google-protobuf (4.33.5-x86_64-linux-musl) bigdecimal rake (>= 13) - hashery (2.1.2) - html-proofer (5.2.0) - addressable (~> 2.3) - async (~> 2.1) - benchmark (~> 0.5) - nokogiri (~> 1.13) - pdf-reader (~> 2.11) - rainbow (~> 3.0) - typhoeus (~> 1.3) - yell (~> 2.0) - zeitwerk (~> 2.5) htmlbeautifier (1.4.3) http_parser.rb (0.8.1) i18n (1.14.8) concurrent-ruby (~> 1.0) - io-event (1.14.2) jekyll (4.4.1) addressable (~> 2.4) base64 (~> 0.2) @@ -124,45 +93,15 @@ GEM rb-inotify (~> 0.9, >= 0.9.10) logger (1.7.0) mercenary (0.4.0) - metrics (0.15.0) - mini_portile2 (2.8.9) - nokogiri (1.19.1) - mini_portile2 (~> 2.8.2) - racc (~> 1.4) - nokogiri (1.19.1-aarch64-linux-gnu) - racc (~> 1.4) - nokogiri (1.19.1-aarch64-linux-musl) - racc (~> 1.4) - nokogiri (1.19.1-arm-linux-gnu) - racc (~> 1.4) - nokogiri (1.19.1-arm-linux-musl) - racc (~> 1.4) - nokogiri (1.19.1-arm64-darwin) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-darwin) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-linux-gnu) - racc (~> 1.4) - nokogiri (1.19.1-x86_64-linux-musl) - racc (~> 1.4) pathutil (0.16.2) forwardable-extended (~> 2.6) - pdf-reader (2.15.1) - Ascii85 (>= 1.0, < 3.0, != 2.0.0) - afm (>= 0.2.1, < 2) - hashery (~> 2.0) - ruby-rc4 - ttfunk public_suffix (7.0.2) - racc (1.8.1) - rainbow (3.1.1) rake (13.3.1) rb-fsevent (0.11.2) rb-inotify (0.11.1) ffi (~> 1.0) rexml (3.4.4) rouge (4.7.0) - ruby-rc4 (0.1.5) safe_yaml (1.0.5) sass-embedded (1.97.3) google-protobuf (~> 4.31) @@ -197,14 +136,8 @@ GEM google-protobuf (~> 4.31) terminal-table (3.0.2) unicode-display_width (>= 1.1.1, < 3) - traces (0.18.2) - ttfunk (1.7.0) - typhoeus (1.5.0) - ethon (>= 0.9.0, < 0.16.0) unicode-display_width (2.6.0) webrick (1.9.2) - yell (2.2.2) - zeitwerk (2.7.5) PLATFORMS aarch64-linux-android @@ -229,7 +162,6 @@ PLATFORMS DEPENDENCIES fastimage - html-proofer htmlbeautifier jekyll (~> 4.3) jekyll-sitemap diff --git a/README.md b/README.md index 7164488..60af4d7 100644 --- a/README.md +++ b/README.md @@ -24,14 +24,6 @@ bundle exec jekyll build Formats output HTML with `htmlbeautifier` automatically via a Jekyll hook. -## Check - -```sh -bin/htmlproofer -``` - -Runs `htmlproofer` against `_site/` to verify links and images. - ## License CC-BY-4.0 diff --git a/bin/htmlproofer b/bin/htmlproofer deleted file mode 100755 index 51b88f5..0000000 --- a/bin/htmlproofer +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env bash -set -e - -MAX_RETRIES=3 - -# linkedin.com, amd.com, seagate.com, corsair.com, reddit.com, apple.com: bot-blocking (links are valid, fail without browser UA) -for i in $(seq 1 $MAX_RETRIES); do - bundle exec htmlproofer _site \ - --ignore-urls "/linkedin\.com/,/amd\.com/,/seagate\.com/,/corsair\.com/,/reddit\.com/,/apple\.com/,/cb341\.dev\/blog\/tags/,/cb341\.dev\/blog\/map-reduce-myself/,/github\.com\/cb341/" \ - --ignore-status-codes "429,999" \ - && exit 0 - echo "Attempt $i failed, retrying..." -done -exit 1 From d80e893926a6368217e20519adf0cb688274d7b7 Mon Sep 17 00:00:00 2001 From: Daniel Bengl Date: Mon, 30 Mar 2026 17:07:24 +0200 Subject: [PATCH 12/12] Improve title --- _posts/2026-03-30-a-optimized-language.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-03-30-a-optimized-language.md b/_posts/2026-03-30-a-optimized-language.md index e115e4b..6bcd989 100644 --- a/_posts/2026-03-30-a-optimized-language.md +++ b/_posts/2026-03-30-a-optimized-language.md @@ -1,5 +1,5 @@ --- -title: "An Optimized Language" +title: "Compressed Language" date: 2026-03-30 description: "English is bloated, math is dense, and the best language for talking to AI sits somewhere in between." tags: ["language", "compression", "ai", "communication"]