Posts
-
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
-
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
-
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
-
References
-
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