Posts
Switching to substack
Smallness
Relational programming simple use Case
0d in python
Mapping a dsl onto python sketches
Swib working paper 2
Working paper swib syntax
Test
Das2json overview
Software interlocking blocks
Deep dive into rewriting
Ohmjs example use Case
Free range programming
The power of peg
Free range programming
Banning the use of if Then Else
Free range programming
Bloatware
Embedding code snippets in new syntaxes
Free range programming
Free range programming
Notations for programming
Jits vs. fast interpreters
Simplicity Familiarity
Thoughts re tomorrowcorp tech demo
The power of ohm and peg
Output queues simplify software
Moores law for software
Deprecating if then else
The origins of silicon valley
Coverage testing i
Rt Recursive Text
Ir Intermediate Representation
Di Design Intent
Free range programming
Free range programming
Free range programming
Breaking free of sequentialism and synchrony
Reading message traces
Rethinking computer programming
Computer science is not about computers
Compiling diagrams to executable code is straight forward
Functions are not subroutines
On type checking dsl syntax
Type checking
Why do we need compilers
Learning asynchronous thinking 0d, fbp, etc.
Thoughts on diagram to json conversion
Herd programming
Global variables are not bad
Static typing and compilation vs design
Control flow
Two Tier software components
0d Sketch Of Internals
0d examples
Towards html case
One input and one output queue per component
Das and concurrency and step wise simultaneity
The model of computering
Sequencing words fail me
Efficiency and cleaving
Peg parsing expression grammars
Design vs type checking
Repls why use a repl?
Parental authority
Hardware actors
Connections are triples
Normalization
Computers are a new medium
Relocation of some posts
Altscript atoms
Advantages of drawware notation
Simplicity
On visual programming
Laws of software development
Ceptre0d Status
T2t transpilation to write a compiler or not to write a compiler?
Stacks and queues
Text vs. diagrams
Diagrams vs. text
Software results in unreliable products
Language affects thinking
Ceptre dungeon crawler example walk Through
Compilation via successive rewriting
Calcification
Memory layout for sector lisp and lisp 1.5
The gods must be crazy
References
Macros for non Lisp languages
Fumbling around and applied science
Alternate paradigm for programming language design
Academia lags behind practice
Programming is many things
Research, engineering, programming are separate concerns
Syntax driven translation
Fundamentals of programming
What is 3d?
Brainstorming on time Preserving software components
Humane computing
Lisp eval and apply
Humane programming languages
Embedding sector lisp and blc a paradigm shift in document structure
Decoding memory disparity unraveling the mysteries of programming languages
Code layout for programming
Software simplicity
Statecharts revelations and opinions
Statecharts papers we love video
Ecs revisited
Readability knob
Visual programming languages vs. textual programming languages vpls vs. tpls
Thoughts on visual programming languages
Programming is not engineering
The meaning of layout
Software cosmology
Three classes of types
The core activities of a program
The advantages of using draw.io for odin0d
Inspiration for 0d
0d was the main goal to create a visual programming language?
0d history
Zero Dependency approach vs flow Based programming
Globals are not the problem
What if? (philosophy)
Experimenting with chatgpt as my ghost writer
Peo generative ai
Mars pathfinder disaster
0d examples
Type checking vs. code emission
On ecs
Crockford and the actor model
The world of software
Software atoms
Examining dynamic program structure
Any Ness
David mcclain on forth
Coding is not engineering
Odin memory layouts
Spaghetti programming
Debugging message passing systems
Find and replace scn
Ux, dx and ax
Programming language design
Visual programming
The problem with general purpose programming languages
Syntax
Recursive text
Expressiveness
Data structures are anti Functional
Computers vs mathematics
Cpus are not computers
Transpilation avoiding edge cases
How i use ohm Js
Breaking the four minute mile of programming
Using a thesaurus for programming language design
Mars pathfinder fiasco and priority inheritance
Hard realtime
Concurrency whats wrong with this picture?
Rule Of 7
Faking concurrency
Moved to Obsidian Publish
Working Code
Programming: First Principles Thinking
PEG Again
DaS - Elements of Diagrammatic Languages (WP1)
ė (eh) Example and Internals
ė - Concurrent Lambdas Working Paper 2 (April 11, 2022)
Zero (0) Dependency Software Components
Visual Languages
UX - Parameter Counting - Gradual Compiling
Tracer Bullets
Smallest Unit of Concurrency
Smallest Unit of Concurrency 2
Orthogonal Code Generation
Ohm Everywhere
Message Class
Future of Programming, Distributed Programming, Visual Programming
Dynamic Binding vs. Static Binding
Deprecating Programming Languages and Operating Systems
Dataless Languages
UX
The Two Aspects of Programming
REPLs Lisp to Bret Victor
On Concurrency
UX vs. Rigor
Efficiency
Class-Based Languages vs. Prototype-Based Languages
#if DaS
JS Objects
Bloatware Reduction via File Descriptors
Multitasking Inverted
Modeling vs. Compilation
UX - User Experience
Dependencies
Compiler Pipelines
Data Descriptors
The Humane Programming Language
Names and Data Descriptors [Working Paper]
Restricting Interfaces (portability, ocg, gcc, λ)
ė - Concurrent Lambdas Working Paper (March 20, 2022)
ASC Working Paper (March 20, 2022)
Notations
Diagram To Code Transpiler (The Plan (WIP))
End User Programming in Pictures
Numbers In Sector Lisp
Prep
Parsing BLC
Beyond Text
Word® vs. Mathematics
Optimizing
Markdown as a programming language
Relations vs. Pointers
Pondering the Lessons From Sector Lisp
Wip notes about tunney's blc
Nesting
Live Coding
Composition
Brainstorming Due to Thinking About Sector Lisp
PROLOG Queries as Commands
Syntax is Frivolous, Paradigms are Essential
Parsing for Transpilers
Diagram to Python Transpiler (d2py)
PREP Tool
Ohm in Ohm
Two Parts of Mathematics
D2F - Diagram to Factbase Compiler
GC in SectorLisp
SectorLisp
Brainstorming wheel reinvention jam secrets of sector lisp 1 1 1
Software Atoms
Writing Less Code Takeaways
TXL
SCN Development for ZodeTrip
FDD In Action
Project Overview
IDEs Instead of Programming Languages and Operating Systems
Composition
Access Control Privileges for Functions
Miscellaneous
Table of contents dec 01 2021
Garbage Collection
Disclaimer
On Diagram Notation
Iterative Design
Performance
Two Syntaxes For Each GPL
On Transpilers
On Building Compilers - Multiple Views and Complexity
On Designing a DSL
Triples in PROLOG
Quote A
Interpreters
Compilers Are Interpreters
VMs and JIT
Linkers
Worlds
PFR and PF (Parsing Find and Replace)
Complexity vs Simplicity II
White Is Black, Black Is White
Debuggers
Wheel reinvention
Typed Packet
Two Syntaxes For Every Language
LEGO® Software
Free Your Mind
DaS (II)
Control Flow is Orthogonal to Data Structuring
Concurrency
We Don't Need Programming Languages Nor Operating Systems
Manifesto
Writing Less Code Takeaways
Whiteboard Takeaways
Tricky Uses of a Paradigm - Takeaways
Table of contents sept 17 2021
ORG Chart Takeaways
Music Lesson Takeaways
Refactoring Takeaways - Architecture
General Purpose Languages - Takeaways
Small Example of Interpreting and Compiling
ABC Glue
Transpiling Diagrams to Bash
Racket Peg Case Forms
Racket Switch Macro
PLD vs PLF (notes)
Racket Macros
Racket Macros
PT Notes for Torlisp - PEG for Zodetrip
PT Notes for Torlisp - Language Jam
Keying For Zodetrip
Compilers vs. Interpreters
SCN Development for ZodeTrip
Ohm-JS
Programmers' UX
Comments
Langjam Suggestion
Exercise Writing A Simple Interpreter
Compiling Diagrams To Code
Plug-Together Software Components
Isolation IV
Communicating State Machines
The Bare Essence
Diagrams As Syntax Is Not Visual Programming
TORLISP (Toronto Lisp Users Group)
Addressing
PLUS Atom Lisp
Multitasking Faking
IoT
Basic Circuits
markdown for design and implementation (WIP)
Diagrams To Code
Diagrams To Code Drawio To Triples
Diagrams To Code - Inferencing
Markdown To Code
Flipping Code
Code Markdown to Structured Pseudo-code
Code Markdown to Bash
Parsing Diagrams - Design Rules
Parsing Diagrams - DaS Workbench Overview
Parsing Diagrams - DaS Workbench 6 Sort
Parsing Diagrams - DaS Workbench 5 Factbase Emitter
Parsing Diagrams - DaS Workbench 4 Factbase Name Collector
Parsing Diagrams - DaS Workbench 3 Attribute Elider Phase
Parsing Diagrams - DaS Workbench 2 Style Expander Phase
Parsing Diagrams - DaS Workbench 1 Decoding Phase
Parsing Diagrams - Connections
Parsing Diagrams - Ports
Jetbrains MPS - First Impressions
Parsing Diagams - Containment
What Is A Program?
Static Typing Is An Optimization
Lisp
Happy Path Culture
Compilation Is An Optimization
Parsing Diagrams - Bounding Boxes
Jetbrains MPS - Before I Look At It
Are Dynamically-Typed Languages Better For Debugging?
Software Components - A Language For Distributed Processing
Software Creativity
Software Brainstorming
Readability
Data Design vs Control Flow Design
Elements of a DI Drawing (WIP)
Elements of DI (WIP)
AST Tree
Transpilation
Grok Workbench
Structured Editing
Indentation to Braces (Case Study)
Dependent Types
Arrowgrams
Case Study - A Language of Types
Nesting and Scoping
Actors
ASON: Tokenizing
Complexity vs. Simplicity
Asynchronous Thinking
Type DSL (SCN)
Conflation of Parameter Delivery and Scheduling
Status
Message Loops vs. Recursion
Functions Are Not ASCs
Software Components (Abridged from Flows)
Happy Path (Part 1)
Flows
Flows (Abridged)
The Big Red Button
Relations
Delegation is for Control Flow as Inheritance is for Data Construction (Working Paper)
ASC (Working Paper)
Functional Programming With Exceptions
Dags and Snippability
Calculators vs Networks
Trees And Crosstalk
Structured Design as Diagrams
Hello World As Diagrams (Working Paper)
Type Descriptors (Working Paper)
Immutability
Data Cleaving
Hierarchical Namespaces
Hierarchical Namespaces
CALL Violates Structured Programming
The Atomic API
Lisp 1.5 Memory
Namespaces
Namespaces Working Paper
Isolation III
Isolation II
Hierarchical Types
Connecting Layers
Brainstorming
Notation
Complexity, Causing Complexity
Expressiveness
Wish List for Structured Software Architecture
The Software Atom
Scalability
PEG vs. Lisp Macros
Everything is Digital
Building a Language
Transpilation 101
How All This Stuff Ties Together
Asynchronous Software Components Design Note
DIL - Design Intent Language
Mathematics vs. Physical Reality
Waterfall Takeaways
Uncomplicated Programming Languages
Operating Sytems in One Page
Construction Industry Takeaways
Code Is Cheap
Business Takeaways
Software Components 101 - Part 15 Joining Components
Agile Takeaways
The Trouble With UNIX
Table of contents since may 13, 2013
Table of contents may 24, 2021
Software Components 101 - Part 14 Checking The Rewrite
RY - Repeat Yourself - As a PL Primitive
Componentization: Measuring Success
UNIX Takeaways
UNIX Takeaways 2
Structured Programming Takeaways
Scalability Takeaways
Scalability 2
Scalability 2
Ssl takeaways
Relational Programming Takeaways
Pattern Matching Takeaways
Object Oriented Takeaways
Normalization
Lisp Takeaways
Layers
Diagram Notation
Denotational Semantics Takeaways
Dataless Language
Data Descriptors Takeaways
DRY vs. RY
Compiler Technology Takeaways
Compiler Technology Takeaways 3
Compiler Technology Takeaways 2
API Takeaways
Software Components 101 - Part 13 Identity Grammar Before Creating a Factbase
Software Components 101 Part 12 Converting Indentation to Nesting
Software Components 101 - Part 11 Starting Over
Java Takeaways
Functional Programming - Takeaways
First Class Functions - Takeaways
Functional programming vs parsing
Diagram Conventions
Thinking is Hard, Coding is Easy
Software Components 101 - Part 10 Tweaking the Grammar to Provide More Information
Simplicity Is Hard
DI Refactoring
Refactoring Takeaways - Architecture
Less Code
Software Components 101 - Part 9 - What's Next?
Software Components 101 Part 8 - Ports
Refactoring
WASM Transpiler Example
Software Components 101 Part 7 - Visual Inspection
Software Components 101 Part 6 Recap
Table of contents
Multitasking Takeaways
Programming
Functional Programming Takeaways 2
Arithmetic Example in Ohm-JS and grasem
Diagram based languages
Concurrency is not parallelism
Software Components 101 - Engine Part 5 Queries
Software Components 101 - Engine Part 4 Review
Software components 101 engine part 3 factbase
Parsing vs regexing
Software components 101 engine part 2 diagram to text
Software components 101 engine development (part 1)
Ohm Editor
Software components 101
Breaking out of synchronous thinking
Tags instead of names
Prolog vs kanren
Breaking long running loops
Software components 101 connection queries
Software components 001
Toolbox languages (2)
Tokenizing
Txl
Subdividing problems
Parsing vs fp pattern matching
Observation why relational programming works
Mutable variables and flags
Function or list?
First class functions
Exhaustive search
Common lisp complexities
Clojure
Backtracking, mathematics, reversability, garbage collection, time Sharing
Actors
Scoping rebol
What if making a compiler was easy?
Recursive design, iterative design by example (3)
Factbases 101
Fdd example workflow
Regex
Incompleteness
Relational programming and the kitchen sink
Failure Driven Design
Variable names are not good enough
Recursive design, iterative design by example (2)
Git could do more
Scoping static vs dynamic
Recursive Design, Iterative Design By Example
Various Playlists
Grasem Tool
Glue Tool
DI - Design Intent
Compiling Diagrams
Two Syntaxes For Every Programming Language
Syntax Primitives
S/SL - Syntax Semantic Language
SCN
Random Anecdotes
Notation vs. DSLs and PLs
Notation Example
ASON Notation Pipeline (building 7 passes)
Kill math
Meta Programming
Recursive design knowns and unknowns
Projectional editing
Peg cheat sheet
Crass simplifications
State, analysis of
Simplicity vs complexity
Programming redux
Mathematics redux
Scls little languages playlist
Patterns
Message passing
Cps considered to be a goto
Bootstrapping
Svg to code (1)
Regex vs peg
Glue manual
Programming paradigms vs syntax
Everything is a fractal
Breaking free of the cell paradigm
Racket peg
The rain god
The f**k program
Testing
Toe for software development
Little language
Learning about compilers quickly
How to design an scl
Divide and conquer in pls
Peg vs. other pattern matchers
Details kill
Asking the right questions
Apl
Component diagrams
Triples
Toolbox languages
Need to know
Indirect calls
Architectural archaelogy
Svg grammar
How many inputs vs how many outputs?
Dynamic anything is bad
Divide and conquer yagni
Components (again)
Universal datatype
Programming language design
Dataless programming language
Scheme to javascript
Fractal design
Dsl in a day
State machines to javascript
Statecharts (again)
The stack is a global variable (again)
Processes are state machines
Superposition 2
Compiling diagrams 2
Blocking
The case for fanout
Curse of the editor
Superposition
Fbp v actors v erlang
One in how many out?
Erlang v actors
What is programming
Factbases
Transpiling diagrams to code 101
Superposition
Pure research vs applied research
Html components arrowgrams
References
Pure research vs applied research
Transpiling diagrams to code 101
Restricted thinking programming editors
Miscellaneous
Induction vs recursion
Transpiling diagrams overview
Architecting, engineering and implementing software
Apple® refunded my money because of a bug
The problem
Sofware kleenex®
Software ceiling
The primary issue
Refactoring
The stack 2
Peg
Compile time and runtime
The stack
The algol bottleneck
Filereader
Dlls
The stack is a list
Concurrency bare bones
Software development roles
Blockchain overview
Anecdote secretary vs. synchrony
5 whys of software components
5 whys of multiprocessing
5 whys of full preemption
Sequencing
Variable names not needed
Type stacks
Two syntaxes for every language
Two stacks for every type
Twenty milliseconds the magic number
Statecharts
State machine for javascript
Shuhari
Scanning and parsing overview
Scalability
Scalability ii
Reuse
Ry vs dry
Programming languages are skins
Programmers vs humans
Parsing and compiling diagrams
Ohminsmallsteps
No Code
New Breed hlls
Multitasking is easy
Mathematics is not reality
Javascript concurrency
Isolation
Introduction
Inspiration
Html is nocode
Html components handling callback logic explicitly
Fbp is no Code for banking apps
Everything is an interpreter
Efficiency
Editor for gratoms
Divide and conquer
Divide and conquer is recursive design
Dsl manifesto
Di design intent
Concurrency is a paradigm
Computing then and now
Computing then and now ii
Complexity
Complexity ii
Call return spaghetti
Box And Arrow dsl for concurrency
Anecdote language learning
subscribe via RSS