Manifesto
https://guitarvydas.github.io/2021/09/23/Manifesto.html
Newer Blogs
Articles written after Sept. 17, 2021 appear at https://guitarvydas.github.io
Table of Contents Sept. 20, 2021
Diagram
Links
Recursive Design
Recursive Design
Divide and conquer
Divide and conquer is recursive design
Divide and conquer is recursive design
Recursive design knowns and unknowns
Recursive design knowns and unknowns
Recursive Design, Iterative Design By Example
Recursive Design, Iterative Design By Example
Recursive design, iterative design by example (2)
Recursive design, iterative design by example (2)
Takeaways
API Takeaways
Thinking is Hard, Coding is Easy
Thinking is Hard, Coding is Easy
WASM Transpiler Example
Compiler Technology Takeaways 3
Compiler Technology Takeaways 3
Diagram Conventions
DRY vs. RY
Refactoring
Compiler Technology Takeaways
Data Descriptors Takeaways
Functional programming vs parsing
Functional programming vs parsing
First Class Functions - Takeaways
First Class Functions - Takeaways
Dataless Language
Functional Programming - Takeaways
Functional Programming - Takeaways
Denotational Semantics Takeaways
Denotational Semantics Takeaways
Java Takeaways
Diagram Notation
Less Code
Layers
Lisp Takeaways
Normalization
Object Oriented Takeaways
Pattern Matching Takeaways
Relational Programming Takeaways
Relational Programming Takeaways
Ssl takeaways
Scalability 2
Takeaways
Takeaways
(Programming - The Good Parts)
Data Design vs Control Flow Design
Data Design vs Control Flow Design
Business Takeaways
Agile Takeaways
Construction Industry Takeaways
Construction Industry Takeaways
Waterfall Takeaways
Scalability Takeaways
Structured Programming Takeaways
Structured Programming Takeaways
UNIX Takeaways 2
UNIX Takeaways
Componentization: Measuring Success
Componentization: Measuring Success
Compiler Technology Takeaways 2
Compiler Technology Takeaways 2
Software Components 101
Software components 101
Software components 101 connection queries
Software components 101 connection queries
Software components 101 engine development (part 1)
Software components 101 engine development (part 1)
Software components 101 engine part 2 diagram to text
Software components 101 engine part 2 diagram to text
Software components 101 engine part 3 factbase
Software components 101 engine part 3 factbase
Software Components 101 - Engine Part 4 Review
Software Components 101 - Engine Part 4 Review
Software Components 101 - Engine Part 5 Queries
Software Components 101 - Engine Part 5 Queries
Software Components 101 Part 6 Recap
Software Components 101 Part 6 Recap
Software Components 101 Part 7 - Visual Inspection
Software Components 101 Part 7 - Visual Inspection
Software Components 101 Part 8 - Ports
Software Components 101 Part 8 - Ports
Software Components 101 - Part 9 - What's Next?
Software Components 101 - Part 9 - What's Next?
Software Components 101 - Part 10 Tweaking the Grammar to Provide More Information
Software Components 101 - Part 10 Tweaking the Grammar to Provide More Information
Software Components 101 - Part 11 Starting Over
Software Components 101 - Part 11 Starting Over
Software Components 101 Part 12 Converting Indentation to Nesting
Software Components 101 Part 12 Converting Indentation to Nesting
Software Components 101 - Part 13 Identify Grsmmar Before Creating Factbase
Software Components 101 - Part 13 Identify Grsmmar Before Creating Factbase
Software Components 101 - Part 14 Checking the Rewrite
Software Components 101 - Part 14 Checking the Rewrite
Software Components 101- Part 15 Joining Components
Software Components 101- Part 15 Joining Components
Software Components
Connecting Layers
Software Components
Software Components
5 whys of software components
Filereader
Html components arrowgrams
Components (again)
Indirect calls
Component diagrams
Need to know
Patterns
Aynchronous Components Design Note
Aynchronous Components Design Note
The Atomic API
Flows
ASC (Working Paper)
Flows (Abridged)
Functions Are Not ASCs
Message Loops vs. Recursion
The Bare Essence
Communicating State Machines
Software Components - A Language For Distributed Processing
Software Components - A Language For Distributed Processing
Plug-Together Software Components
Plug-Together Software Components
Programming
Programming
Programming
The Big Red Button
META
META
Introduction
Table of Contents May 24
Table of Conents May 13
DI - Design Intent
DI - Design Intent
Di design intent
DI - Design Intent
Elements of DI (WIP)
Elements of a DI Drawing (WIP)
Elements of a DI Drawing (WIP)
Design Intent Lanuguage
DaS
DaS
Parsing Diagrams
Parsing Diagrams
Compiling Diagrams To Code
Diagrams To Code
Diagrams To Code Drawio To Triples
Diagrams To Code Drawio To Triples
Parsing Diagrams - DaS Workbench Overview
Parsing Diagrams - DaS Workbench Overview
Parsing Diagrams - Bounding Boxes
Parsing Diagrams - Bounding Boxes
Parsing Diagrams - Containment
Parsing Diagrams - Containment
Parsing Diagrams - Ports
Parsing Diagrams - Connections
Parsing Diagrams - Connections
Diagrams To Code - Inferencing
Diagrams To Code - Inferencing
Parsing Diagrams - DaS Workbench 1 Decoding Phase
Parsing Diagrams - DaS Workbench 1 Decoding Phase
Parsing Diagrams - DaS Workbench 2 Style Expander Phase
Parsing Diagrams - DaS Workbench 2 Style Expander Phase
Parsing Diagrams - DaS Workrench 3 Attribute Edider Phase
Parsing Diagrams - DaS Workrench 3 Attribute Edider Phase
Parsing Diagrams - DaS Workbench 4 Factbase Name Collector
Parsing Diagrams - DaS Workbench 4 Factbase Name Collector
Parsing Diagrams - DaS Workbench 5 Factbase Emitter
Parsing Diagrams - DaS Workbench 5 Factbase Emitter
Parsing Diagrams - DaS Workbench 6 Sort
Parsing Diagrams - DaS Workbench 6 Sort
Parsing Diagrams - Design Rules
Parsing Diagrams - Design Rules
Transpiling diagrams overview
Restricted thinking programming editors
Restricted thinking programming editors
Parsing and compiling diagrams
Parsing and compiling diagrams
Editor for gratoms
Transpiling diagrams to code 101
Transpiling diagrams to code 101
Box And Arrow dsl for concurrency
Box And Arrow dsl for concurrency
Processes are state machines
Compiling diagrams 2
Breaking free of the cell paradigm
Breaking free of the cell paradigm
Syntax Primitives
Compiling Diagrams
Diagram based languages
Programmers’ UX
Structured Design as Diagrams
Diagrams As Syntax Is Not Visual Programming
Diagrams As Syntax Is Not Visual Programming
PT Notes for TORLISP - Language Jam
PT Notes for TORLISP - Language Jam
Transpiling Diagrams to Bash
Visual Programming
Visual Programming
Arrowgrams
Curse of the editor
Hello Wold As Diagrams (Working Paper)
Hello Wold As Diagrams (Working Paper)
Concurrency
Concurrency
Concurrency is not parallelism
Concurrency is not parallelism
Box And Arrow dsl for concurrency
Box And Arrow dsl for concurrency
Call return spaghetti
Concurrency is a paradigm
Javascript concurrency
Multitasking is easy
5 whys of full preemption
5 whys of multiprocessing
Sequencing
Concurrency bare bones
Html components handling callback logic explicitly
Html components handling callback logic explicitly
The problem
Blocking
Breaking out of synchronous thinking
Breaking out of synchronous thinking
Breaking long running loops
Multitasking Faking
Asynchronous Thinking
CALL RETURN
CALL RETURN
Call return spaghetti
Conflation of Parameter Delivery and Scheduling
Conflation of Parameter Delivery and Scheduling
CALL Violates Structured Progamming
CALL Violates Structured Progamming
Sequencing
Sequencing
Sequencing
Complexity
Complexity
Complexity
Complexity ii
Simplicity vs complexity
Complexity vs. Simplicity
Complexity, Causing Complexity
Complexity, Causing Complexity
Operating System in One Page
ALGOL Bottleneck
ALGOL Bottleneck
The algol bottleneck
Computing
Computing
What Is A Program?
Computing then and now
Computing then and now ii
New Breed hlls
Programmers vs humans
The primary issue
Twenty milliseconds the magic number
Twenty milliseconds the magic number
Programming redux
IoT
PROLOG
PROLOG
Scheme to javascript
Transpilers
Transpilers
Dsl manifesto
Scanning and parsing overview
Toolbox languages
Svg grammar
Learning about compilers quickly
Learning about compilers quickly
Scls little languages playlist
Scls little languages playlist
Toolbox languages (2)
Transpilation
Transpilation 101
Grok Workbench
PEG
PEG
Peg
Ohminsmallsteps
Ohm-JS
PEG vs Lisp Macros
Parsing vs regexing
Racket peg
Peg cheat sheet
Regex vs peg
Peg vs. other pattern matchers
Peg vs. other pattern matchers
Efficiency
Efficiency
Efficiency
Everything is an interpreter
Compile Time vs Run Time
Compile Time vs Run Time
Dlls
Compile time and runtime
SCN - Solution Centric Notation
SCN - Solution Centric Notation
Notation
Dsl in a day
How to design an scl
Little language
SCN
Notation vs. DSLs and PLs
No Code
No Code
No Code
Fbp is no Code for banking apps
Fbp is no Code for banking apps
Html is nocode
FBP
FBP
Fbp v actors v erlang
The case for fanout
Actors
Actors
Actors
Actors
Erlang v actors
Inspiration
Inspiration
S/SL - Syntax Semantic Language
S/SL - Syntax Semantic Language
Inspiration
Mathematics
Mathematics
Mathematics is not reality
Induction vs recursion
Apl
Kill math
Mathematics redux
Crass simplifications
Dependent Types
Mathematics vs. Physical Reality
Mathematics vs. Physical Reality
Typing
Typing
Two stacks for every type
Type stacks
Hierarchical Types
PLs (Programming Languages)
PLs (Programming Languages)
Programming language design
Programming languages are skins
Programming languages are skins
Variable names not needed
Divide and conquer in pls
Asking the right questions
Two Syntaxes For Every Programming Language
Two Syntaxes For Every Programming Language
Variable names are not good enough
Variable names are not good enough
Txl
Breaking long running loops
Tags instead of names
PLD vs PLF (notes)
The Trouble With UNIX
Uncomplicated Programming Languages
Uncomplicated Programming Languages
RY (Repeat Yourself)
RY (Repeat Yourself)
RY - Repeat Yourself as a Programming Language primitive
RY - Repeat Yourself as a Programming Language primitive
Git could do more
Ry vs dry
Software Architecture
Software Architecture
Comments
Reuse
Architectural archaelogy
Details kill
Architecting, engineering and implementing software
Architecting, engineering and implementing software
Data Cleaving
Code is Cheap
Wish List for Software Architecture
Wish List for Software Architecture
Dependencies & Scalability
Dependencies & Scalability
Scalability
Scalability ii
Trees and Crosstalk
Dags and Snippability
Calculators vs. Networks
Functional Programming with Exceptions
Functional Programming with Exceptions
Scalability
Software Components (Abridged from Flows)
Software Components (Abridged from Flows)
References
References
References
Shuhari
Shuhari
Shuhari
State Machines
State Machines
State machine for javascript
State machines to javascript
StateCharts
StateCharts
Statecharts
Statecharts (again)
Software Development
Software Development
Software development roles
Refactoring
Software ceiling
Apple® refunded my money because of a bug
Apple® refunded my money because of a bug
Sofware kleenex®
Miscellaneous
Pure research vs applied research
Pure research vs applied research
What is programming
One in how many out?
How many inputs vs how many outputs?
How many inputs vs how many outputs?
Divide and conquer yagni
Toe for software development
Dynamic anything is bad
Holy Grail of Software Development
Holy Grail of Software Development
What if making a compiler was easy?
What if making a compiler was easy?
Superposition
The Stack
The Stack
The stack is a list
The stack 2
The stack
The stack is a global variable (again)
The stack is a global variable (again)
Layered Design
Layered Design
Superposition
Superposition 2
Fractal design
Dataless programming language
Nesting and Scoping
FB - Factbases
FB - Factbases
Factbases
Factbases 101
Triples
Triples
Triples
Universal datatype
Testing
Examples
Examples
Glue manual
Svg to code (1)
Notation Example
ASON Notation Pipeline (building 7 passes)
ASON Notation Pipeline (building 7 passes)
Recursive design, iterative design by example (3)
Recursive design, iterative design by example (3)
Arithmetic Example in Ohm-JS and grasem
Arithmetic Example in Ohm-JS and grasem
ABC Glue
Small Example of Interpreting and Compiling
Small Example of Interpreting and Compiling
Techniques
Techniques
Bootstrapping
Cps considered to be a goto
Message passing
State, analysis of
Meta Programming
Incompleteness
Scoping static vs dynamic
Function or list?
Relational programming and the kitchen sink
Relational programming and the kitchen sink
Regex
Projectional Editing
Projectional Editing
Projectional editing
Tools
Tools
Glue Tool
Grasem Tool
Ohm Editor
Youtube Playlists
Youtube Playlists
Various Playlists
FDD - Failure Driven Design
FDD - Failure Driven Design
Failure Driven Design
Fdd example workflow
Subdividing problems
Lisp
Happy Path (Part 1)
Paradigms
Paradigms
First class functions
Clojure
Backtracking, mathematics, reversability, garbage collection, time Sharing
Backtracking, mathematics, reversability, garbage collection, time Sharing
Common Lisp
Common Lisp
Common lisp complexities
Relational Programming
Relational Programming
Exhaustive search
Prolog vs kanren
Observation why relational programming works
Observation why relational programming works
Pattern Matching
Pattern Matching
Mutable variables and flags
Parsing vs fp pattern matching
Parsing vs fp pattern matching
Isolation
Isolation
Tokenizing
Isolation II
Isolation III
Isolation IV
Anecdotes
Anecdotes
Anecdote secretary vs. synchrony
Anecdote secretary vs. synchrony
Building a Language
The f**k program
The rain god
Anecdote language learning
Random Anecdotes
Relative namespaces
Relative namespaces
Hierarchical Namedpaces
Namespaces
Namespaces Working Paper
Lisp (Frits van der Wateren)
Lisp (Frits van der Wateren)
Lisp 1.5 Memory
PLUS Atom Lsip
FP (Functional Programming)
FP (Functional Programming)
Immutability
Type DSL
Type DSL
Type Descriptors (Working Paper
Type Descriptors (Working Paper
Case Study - A Language of Types
Case Study - A Language of Types
Type DSL (SCN)
miscellaneous
miscellaneous
Status
Structured Editing
TORLISP (Toronto Lisp Users Group)
TORLISP (Toronto Lisp Users Group)
Delegation is for Control Flow as Inheritance is for Data Construction (Working Paper)
Delegation is for Control Flow as Inheritance is for Data Construction (Working Paper)
machine readability
machine readability
Readbility
Relations
ASON
ASON
ASON: Tokenizing
Markdown for Code
Markdown for Code
Indentation to Braces (Case Study)
Indentation to Braces (Case Study)
Flipping Code
Markdown To Code
Code Makdown to Structured Pseudocode
Code Makdown to Structured Pseudocode
Markdown for Design and Implementation (WIP)
Markdown for Design and Implementation (WIP)
Code Markdown to Bash
ASTs
ASTs
AST Tree
Creativity
Creativity
Software Creativity
Brainstorming
Software Brainstorming
Debugging
Debugging
Are Dynamically-Typed Languages Better For Debugging?
Are Dynamically-Typed Languages Better For Debugging?
Jetbrains MPS
Jetbrains MPS
Jetbrains MPS - Before I Look At It
Jetbrains MPS - Before I Look At It
JetBrains MPS - First Impressions
JetBrains MPS - First Impressions
Compilation
Compilation
Compilation Is An Optimization
Compilation Is An Optimization
Static Typing Is An Optimization
Static Typing Is An Optimization
Happy Path
Happy Path
Happy Path Culture
Basics
Basics
Basic Circuits
Addressing
Compilers vs. Interpreters
Everything Is Digital
Expressiveness
How All This Stuff Ties Together
How All This Stuff Ties Together
Exercises
Exercises
Langjam Suggestion
SCN Development for Zodetrip
Exercise Writing A Simple Interpreter
Exercise Writing A Simple Interpreter
Game Development
Game Development
Keying For Zodetrip
Macros
Macros
Racket Macros
Racket Macros (2)
Racket Switch Macro
Racket Peg Case Forms
PT Notes for TORLISP - PEG for Zodetrip
PT Notes for TORLISP - PEG for Zodetrip
The Software Atom
The Software Atom