The Curious Engineer

All blogs / Software / engineering practice

Programming Simplicity

programmingsimplicity.substack.com

Exploring simplicity in programming. Click to read Programming Simplicity, by Paul Tarvydas, a Substack publication with hundreds of subscribers.

Software / engineering practiceEssays / personal

’24’25’26
Posts
412 from 14 Jun 2024 to 26 Oct 2026
Posting
weekly (121 in the last year)
Kind
personal blog
Feed
https://programmingsimplicity.substack.com/feed

2026 99

  1. Good Software Is More Than Just Correct Code
  2. What Makes Programming Simpler?
  3. Three Tiers of Programming a Device
  4. Text vs. Visual Notations
  5. Why Diagrams and DPLs?
  6. Why T2T?
  7. Stop Writing What Diagrams Can Generate
  8. First Principles Thinking - 5 Whys Approach
  9. The Synchronous Straitjacket
  10. C Port of PBP Kernel
  11. AI Slop vs. Artistry
  12. TDPL, BUPL, and the Trade-Off We Never Revisited
  13. Experiment — Projectional Viewer
  14. Simplicity Is in the Eye of the Beholder
  15. Macros With OhmJS
  16. Skipping With OhmJS
  17. Preventing the Collapse of Civilization
  18. Opinions About Compiler Building
  19. Stop Confusing Languages With Compilers
  20. Simplification and Two Kinds of Code
  21. Implementing The Experimental ST Meta-Syntax
  22. Experiment - Separating Architecture From Code
  23. Languages That Stretch Your DI Capabilities and Imagination
  24. Five Whys for Software Component Isolation
  25. The Parts Based Programming Kernel
  26. Separating Architecture From Implementation
  27. Concurrency (Part 2 of 2)
  28. Concurrency (Part 1 of 2)
  29. Repeating Architectural Patterns
  30. AI Is No Code
  31. Anti Assimilation
  32. The Hardware Changed. The Software Didn’t.
  33. Software Development Has a Brainstorming Problem
  34. One Language To Rule Them All
  35. We Painted Ourselves Into a Corner
  36. Words
  37. Computation vs. The Arrow of Time
  38. Concurrency Is Not Parallelism
  39. FDD - Failure Driven Development
  40. Ideas for Porting PBP to Go
  41. Forth Haiku Compendium
  42. You Already Know PBP
  43. The Limits of Mathematical Computation Applied to Physical Hardware
  44. From State Machine Diagram to Python
  45. Source Code Control Doesn’t Need to Store Source Code
  46. Understanding Smallness and Speed
  47. Some Thoughts About The Computing Historian Recovering Ideas We Threw Away
  48. Y2K: When Code Became Archaeology
  49. LLMs as Design Recovery Engines
  50. Jail-Breaking Parser Technology (A Slight Return)
  51. Flow
  52. Structured Software Architecture
  53. Little Language Case Study - Generating Code for Simple State Machines
  54. The Case for Composable Notations (6 of 5) - WIP - Notations in Progress
  55. The Case for Composable Notations (5 of 5) UNIX Already Showed Us the Way
  56. The Case for Composable Notations (4 of 5) Ease of Expression Is the Whole Point
  57. The Case for Composable Notations (3 of 5) State Isn’t The Enemy
  58. The Case for Composable Notations (2 of 5) The Restrictions That Came With the Cow
  59. Working on Rewriting the Preoptimizer Preopt.ohm
  60. The Wrong Spherical Cow - First Principles of Parts Based Programming
  61. The Case for Composable Notations (1 of 5) The Spherical Cow We Forgot We Were Riding
  62. Multiple Notations In A Single Project
  63. Drafting Rules for Node-and-Wire Diagrams
  64. Architectural Portability
  65. Who Am I and Why Should You Care?
  66. What I’ve Learned From Forth Haiku Thus Far
  67. Macros Don’t Belong In a Language
  68. Staged Computation: Whittling Down Source Code with t2t
  69. Scalable vs. Spaghetti Architecture
  70. Are We Really Better Than Sketchpad?
  71. Encapsulation Is Not Enough
  72. Forth Haiku GPU and CPU Pipelines
  73. Forth Haiku Optimizer
  74. DRY is Overrated
  75. Already Existing External Protocols
  76. Generate Kernels, Not More Code
  77. There Is Only One Programming Language
  78. Compilation Using Two Stage Code Emission
  79. Pond’ring Fan-Out and Fan-in
  80. DIY Forth - Forth Haiku Analysis Part 2
  81. DIY Forth - Forth Haiku Analysis Part 1
  82. Do We Need a New Programming Language for the AI Era?
  83. Why Your Operating System is Still Trapped in 1960
  84. Why Are Functions Less Reliable Than Hardware?
  85. Everything Is Not a Function (And Your CPU Knows It)
  86. Make Programming Distributed and Asynchronous Again
  87. Make Programming Fun Again
  88. Why Modern Software Is So Bloated: We Forgot There Are Many Ways to Program
  89. Brusselator - Pond’ring Aloud
  90. Error Messages Are Lying to You (And That’s Okay for Machines)
  91. Layered Abstraction
  92. What’s Inside a Hard Disk?
  93. Operating Systems: A Solution to a Self-Inflicted Problem
  94. LEGO Block Software
  95. When Parallel Isn’t Really Parallel
  96. Jail-breaking Parser Technology
  97. What is Programming?
  98. Stop Digging and Start Building: Why We Need LEGO Parts, Not Deeper Type Systems
  99. PBP Black Box Abstraction, Ports, Fan-out, Fan-in

2025 191

  1. Fundamentals of Compilers
  2. PBP-LLM: Automated Problem Discovery Using Language Models
  3. The Function Trap: Why Your Favourite Abstraction Is Sabotaging Your Code
  4. AOT vs. JIT Type Checking
  5. Crossing the Great Divide From Difficult to Easy
  6. Hundreds of Threads
  7. Evidence In Support of Visual Programming
  8. Viewing Forth
  9. The Deployment Delusion: How Software Learned to Stop Worrying and Love the Bug
  10. We Lost Something: 1970s REPLs Were Better Than Modern Development Environments
  11. The Problem With Global Variables
  12. Program Design and Engineering
  13. Show Don’t Tell
  14. How C Accidentally Locked Programming Into a Single Paradigm
  15. Complexity
  16. On Diagrammatic Syntax
  17. Syntax Is Cheap. Paradigms Matter.
  18. Message Passing in PBP vs. Erlang
  19. Why Distributed Systems Need Better Text Parsing
  20. The Hidden Gem in S/SL: Why Dataless Languages Matter
  21. Forth-ish
  22. PBP Kernel Portability
  23. Why Every Language Is Really an Interpreter (And Why That’s Actually Good)
  24. Efficient Function Nesting
  25. Simple Assembler and Simple CPUs First
  26. What Was UNIX V1 Written In?
  27. The Spherical Cows of Programming
  28. Rethinking Memory Assumptions in Algorithm Design
  29. Failure Driven Design
  30. How I Execute Diagrams As Code
  31. Portability
  32. The AST Trap: How Compiler Design Mirrors Software Bloat
  33. Hardware Stockholm Syndrome
  34. The Marketing of C
  35. Software Footprints
  36. How To Use Parts Based Programming - PBP
  37. Thoughts About the Actor Model
  38. C Compiler
  39. Little Networks
  40. Biological Thinking vs. Synchronous / Sequential Thinking
  41. Recursive, Asynchronous Layering: What Shell Scripts Teach Us About Program Architecture
  42. Simplicity
  43. We’ve Always Done It This Way
  44. The Point of Programming
  45. Programming: The Good Parts
  46. Various Programming Paradigms
  47. PBP Part Basics
  48. Type Checking Continued
  49. Type Checking is a Symptom, Not a Solution
  50. What UNIX Pipelines Got Right (And How We Can Do Better)
  51. Pond’ring CPUs
  52. New Syntax For Recursion
  53. WIP Experiment With LLM Code Snippet Language
  54. Example of Simplicity - Rebol 2.7 GUI System
  55. Protocols and Synchronization
  56. The Illusion of Concurrency II
  57. The Illusion of Concurrency
  58. Towards Asynchronous Programming Workflows and Languages
  59. De-Spaghettifying Control Flow
  60. Diversifying Programming Workflow
  61. Growing System Size
  62. Procedures, Subroutines, Functions
  63. Silicon and Parallelism
  64. Sequencing and Order
  65. State Machines and State Explosion
  66. Homebrew Computer Archaeology
  67. Experimenting With Opcodes of Tomorrow III
  68. The Opcodes of Tomorrow Part II
  69. Random Language Design Thoughts
  70. Compiling Comments
  71. Coroutines and Threads and Multi-processing
  72. Scheme To Javascript Demo
  73. The Wonders of State
  74. CRT Basics
  75. On Options For Programming
  76. Programming and Macros in 2025
  77. Structure Sharing in Lisp vs. Other Programming Languages
  78. Enumerate Every Case
  79. The Opcodes of Tomorrow
  80. Ten Cent CPUs
  81. Lisp Source Code
  82. Modernizing Program Compilation
  83. Scheme to Javascript in PBP - Live Debugging Session
  84. Prolog Related References
  85. Stifling of Imagination
  86. Using Existing PLs as Assembly Languages
  87. String Interpolation Continued
  88. Solution Centric Programming
  89. Thoughts on Hindrances to Asynchronousity
  90. Massive Parallelism
  91. Understanding CPUs From First Principles
  92. On Programming Paradigms
  93. Low Level Programming
  94. Bad Smells In Our Programming Workflow
  95. FP, Programming and CPUs
  96. Beyond Functions - Understanding Control Flow as Program Orchestration
  97. Sheet Music vs. FP
  98. One Paradigm to Rule Them All
  99. Purpose of Programming Languages
  100. Subroutines vs. Functions
  101. Tree-Oriented Programming Instead of Line-Oriented Programming
  102. FP Is Not Data Flow
  103. Taming the Code Jungle: A Structured Approach to Preventing Software Sprawl
  104. Two Syntaxes For Every Language
  105. String Interpolation
  106. Two Key Concepts in Programming
  107. Excerpt - How To De-Bloatify Using Current Programming Languages
  108. Musings on Software Simplicity
  109. Custom Programming Languages and Better IDEs
  110. On Bloatware
  111. Failure Driven Development
  112. Software Development Phases
  113. Programming Is Multi-Paradigmatic
  114. Systems Programming
  115. Dropping the Cottage Industry Mindset for Programming
  116. Memory Is Just An Array Of Bytes
  117. Notations
  118. Vms
  119. Is Sector Lisp Small Only Due To Assembler Tricks?
  120. Programming Meme
  121. One Language To Rule Them All Syndrome
  122. LLM-Based Programming
  123. New Programming Language Design - Part 2 Pond’ring Aloud [WIP]
  124. New Programming Language Design - Pond’ring Aloud [WIP]
  125. Remics - The Study of the Fundamentals of Reprogrammable Machines
  126. Enhancing Programming With Parts Based Programming
  127. Multiprocessing
  128. Why Full Preemption?
  129. Software LEGO® Blocks
  130. Notes Regarding Diagrams as Syntax
  131. Simple Ohm Grammar
  132. Before and After C
  133. Forks In The Road
  134. Mental Agility Jams for Programming
  135. Types Are Unnecessary
  136. The Problem With Function Call Coupling
  137. Linear Logic - Pond’ring Aloud
  138. Modern Programming Issues
  139. Parsing
  140. Towards PBP / 0D for Bash - Pond’ring Aloud
  141. Lisp Macros - Pond’ring Aloud
  142. Data Model nano-DSL (“SCN”)
  143. Transistors as Logic Gates
  144. Logic Gate Basics Using Transistors
  145. How A Transistor Makes A Logic Inverter
  146. On REPLs
  147. Composing Multi-Node Systems
  148. PUSM - Programming Using the SICP Method
  149. Programming Language Sizes
  150. SEXP Syntax in Ohm
  151. Readability - Human vs. Machine
  152. The Best Programming Language
  153. How Did We Get Here?
  154. On Reasoning About Time, Sequencing and Ordering
  155. On Programming Using Non-Gutenberg Syntax
  156. DI and Readability
  157. Structured Message Passing
  158. State Explosion
  159. Thinking About Timing Issues
  160. Subroutines are not Functions
  161. Coroutine Secrets
  162. Rethinking Programming For The 2020s
  163. Origins of Multitasking and Coroutines
  164. Simplicity vs. Functional Programming
  165. More Thoughts About Pipelines vs. Functions
  166. Function Chains vs. Pipelines
  167. Layering
  168. On Structured Message Passing
  169. FEXPRs And The Invention Of Lisp Macros
  170. Of Interest
  171. Extreme Decoupling
  172. Divide and Conquer vs. Cognitive Loading
  173. Concurrency and Strip Shredding
  174. Functions and Pipes
  175. Statechart Programming Languages
  176. Simplicity
  177. On Modernizing Cartridge Based Applications
  178. Whence Bloat?
  179. JVM vs Lisp Eval
  180. Practical Parallelism
  181. Async vs. Sync
  182. Forward Into The Past
  183. XML vs Lisp
  184. Pond’ring Aloud: Writing Articles, Blog Posts (Part 3)
  185. Escaping Function-Based Programming
  186. Pond’ring Aloud: Writing Articles, Blog Posts (Part 2)
  187. Pond’ring Aloud: Writing Articles, Blog Posts
  188. The Future of Programming
  189. Towards Diagram Compilation
  190. Secrets of Part-Based Programming
  191. Understanding Pattern Matching

2024 122

  1. Experiments With LLVM
  2. Understanding Cache Coherence
  3. Understanding Computers
  4. Async and Await in Synchronous Languages are not Asynchronous
  5. Closures Are State Machines
  6. How Gutenberg Harmed Math
  7. Oscilloscopes and Hand-held Calculators
  8. The Art of Minimalism in Design: Why Less is More
  9. The Version Control Dilemma: Why Git Falls Short for Software Designers
  10. Design Engineering vs. Production Engineering
  11. Diagrams to Generate and Run Python Code
  12. Building A DSL - Example RT to Common Lisp
  13. 2024-12-12-Building A DSL - Example DSL That Generates Python Code
  14. Building A DSL (References and Video)
  15. Text-Based Portability
  16. Concurrency Ain’t Concurrent
  17. Thoughts on Nova vs. Ceptre
  18. Combining Prolog and Javascript into a Programming Language
  19. RT - Now What?
  20. RT Transpiler
  21. Peephole Optimization Example
  22. Writing a Compiler in 2024
  23. 2024-05-26-Experiment: Mapping a DSL onto Python in Sketches
  24. Reprogrammable Electronic Machines
  25. Writing A JSON Parser Using T2T in Only 2.5 Hours
  26. Compilers vs. Interpreters
  27. Small C
  28. Building Software Using Black Boxes
  29. Environment Affects Thought
  30. Programming Language Workbench - Beginnings
  31. C Doubly-Linked List Rough-In
  32. Building a REPL in 2024
  33. Using JSON Instead of STDOUT
  34. Yet More About Single-Paradigm And Multi-Paradigm Thinking And The Function-Based Paradigm’s Unsuitability For Expressing Concurrency
  35. Synchronous Execution of Code
  36. Single-Paradigm vs. Multi-Paradigm Thinking (Slight Return)
  37. Experiment With A Simple REPL For A DPL
  38. Capturing Iterative Design Thoughts
  39. Visual Programming
  40. Experiments With Drawware
  41. Multiple Input Ports, Only One Input Queue
  42. Beginning to Work On a REPL for Drawware
  43. Single-Paradigm vs. Multi-Paradigm Thinking
  44. The Future of Programming
  45. Programming Substrates IMO
  46. Thinking About DaS REPLs
  47. Parental Authority (2)
  48. Parental Authority (2)
  49. Layering Code
  50. ASCII Addiction
  51. Towards A Better/Richer IDE
  52. Testing
  53. Towards a Better REGEX
  54. The One True Programming Language
  55. Tree Current Node Brainstorming
  56. Control Flow is Not Data
  57. Towards an Ideal Development Workflow
  58. Beliefs That Adversely Affect the State of Programming
  59. Functional Programming is Letting Us Down
  60. Experiments With a Python Indenter
  61. Programming Is Too Complicated
  62. Experimenting With Whitespace In Identifiers
  63. Using Space-Skipping While Preserving Whitespace in Strings and Comments
  64. Why Do We Use Whitespace To Separate Identifiers in Programming Languages?
  65. Experiments With Text to Text Transpilation
  66. Upgrading Our Programming Paradigm
  67. Peeking Behind the Curtain
  68. Using Many Nano-DSLs
  69. Computational Thinking Run Amok
  70. Function Entanglement vs Structured Message Passing
  71. Character Grids vs Overlapping
  72. Capt. Grace Hopper on Future Possibilities: Data, Hardware, Software, and People, 1982
  73. Quality Assurance
  74. Processes vs Closures
  75. Preemption and Time-Sharing
  76. Questioning Whether Code Is Data
  77. Alternate Syntaxes v Old Fashioned Approaches
  78. Drawing Code
  79. Why Do We Use Text For Programming Languages?
  80. Syntactic Overloading of =
  81. Call Return Spaghetti
  82. Program Comprehension
  83. Towards Metrics for Refactoring
  84. Swing Thoughts About Programming
  85. On Parsing
  86. Software Dark Matter
  87. 2024-08-03-Functional vs. Function-Based Thinking and Mono-paradigmatic Programming
  88. 2024-08-02-Anatomy of a Function Call
  89. 2024-08-01-What’s The Problem?
  90. 2024-07-30-Diagram Compiler Status
  91. 2024-07-30-Blog URL Correction
  92. 2024-07-22-Paradigms For Thinking About Problems And Programs
  93. 2024-07-22-Compiling Diagrams to Code
  94. 2024-07-22-Secret of Using Diagrams as Code
  95. 2024-07-19-Why Do We Need Operating Systems?
  96. 2024-07-17-Rhetorical Questions
  97. 2024-07-17-Thinking About The Game Of Pong In Hardware And Software
  98. 2024-07-07-Can Software Be Chunked And Layered?
  99. What’s Wrong With The Function-Based Paradigm?
  100. Message Ordering - Simple Case Study
  101. Subroutines Are Not Functions
  102. Programming Languages Are Essentially The Same
  103. Structured Message Passing
  104. Fan-out and Abstraction and A Single Input Queue
  105. Example Message Flow
  106. Devising Specific Notations
  107. Towards Scheme to Python Transpilation
  108. Good Enough
  109. Computers Are Not Printing Presses
  110. Subroutines Are Not Functions
  111. Asynchrony - Little Networks
  112. Structured Message Passing
  113. Routing 101 Part 1
  114. 2024-06-26-Exploring Technique and Notations for Augmenting DX
  115. 2024-06-26-Programming Baggage
  116. 2024-06-24-Complexity Elision Pyramid
  117. 2024-06-23-Ceptre Overview
  118. 2024-06-15-Failure Driven Development
  119. 2024-06-15-Not Standing On The Shoulders Of Giants
  120. 2024-06-14-Connections are Triples
  121. 2024-06-14-Smallness
  122. Coming soon