Manifesto
https://guitarvydas.github.io/2021/09/23/Manifesto.html
Newer Blogs
Articles written after Dec. 01, 2021 appear at https://guitarvydas.github.io
TOC Diagram
TOC URLs
Manifesto
Manifesto
Manifesto
Free Your Mind
Disclaimer
META
META
Introduction
Table of Contents May 24
Table of Conents May 13
Takeaways
Takeaways
(Programming - The Good Parts and The Bad Parts)
Compiler Technology Takeaways 2
Compiler Technology Takeaways 2
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
First Class Functions - Takeaways
First Class Functions - 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
Scalability Takeaways
Structured Programming Takeaways
Structured Programming Takeaways
UNIX Takeaways 2
UNIX Takeaways
Componentization: Measuring Success
Componentization: Measuring Success
Functional programming vs parsing
Functional programming vs parsing
Business Takeaways
Functional Programming - Takeaways
Functional Programming - Takeaways
Agile Takeaways
Construction Industry Takeaways
Construction Industry Takeaways
Waterfall Takeaways
Whiteboard Takeaways
Tricky Uses of Paradigms - Takeaways
Tricky Uses of Paradigms - Takeaways
Writing Less Code
Dataless Language
Data Design vs Control Flow Design
Data Design vs Control Flow Design
Software Components 101
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
Software Components
LEGO® Software
Connecting Layers
5 whys of software components
Filereader
Html components arrowgrams
Components (again)
Indirect calls
Component diagrams
Need to know
Patterns
Functions Are Not ASCs
Flows
ASC (Working Paper)
Flows (Abridged)
The Atomic API
Aynchronous Components Design Note
Aynchronous Components Design Note
Message Loops vs. Recursion
The Bare Essence
Communicating State Machines
Plug-Together Software Components
Plug-Together Software Components
Software Components - A Language For Distributed Processing
Software Components - A Language For Distributed Processing
Programming
Programming
Programming
The Big Red Button
Recursive Design
Recursive Design
Divide and conquer is recursive design
Divide and conquer is recursive design
Recursive design knowns and unknowns
Recursive design knowns and unknowns
Divide and conquer
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)
DI - Design Intent
DI - Design Intent
DI - Design Intent
Di design intent
Design Intent Lanuguage
Elements of DI (WIP)
Elements of a DI Drawing (WIP)
Elements of a DI Drawing (WIP)
Visual Programming
Visual Programming
Arrowgrams
Hello Wold As Diagrams (Working Paper)
Hello Wold As Diagrams (Working Paper)
Curse of the editor
DaS
DaS
Restricted thinking programming editors
Restricted thinking programming editors
Transpiling diagrams overview
Parsing and compiling diagrams
Parsing and compiling diagrams
Editor for gratoms
Transpiling diagrams to code 101
Transpiling diagrams to code 101
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
Box And Arrow dsl for concurrency
Box And Arrow dsl for concurrency
Transpiling diagrams to code 101
Transpiling diagrams to code 101
DaS II
Programmers’ UX
PT Notes for TORLISP - Language Jam
PT Notes for TORLISP - Language Jam
Transpiling Diagrams to Bash
On Diagram Notation
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 - Containment
Parsing Diagrams - Containment
Parsing Diagrams - Ports
Parsing Diagrams - Connections
Parsing Diagrams - Connections
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 6 Sort
Parsing Diagrams - DaS Workbench 6 Sort
Parsing Diagrams - Design Rules
Parsing Diagrams - Design Rules
Diagrams To Code - Inferencing
Diagrams To Code - Inferencing
Structure Design as Diagrams
Diagrams As Syntax Is Not Visual Programming
Diagrams As Syntax Is Not Visual Programming
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 - Bounding Boxes
Parsing Diagrams - Bounding Boxes
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
Asynchronous Thinking
Multitasking Faking
Concurrency
CALL RETURN
CALL RETURN
Call return spaghetti
CALL Violates Structured Progamming
CALL Violates Structured Progamming
Conflation of Parameter Delivery and Scheduling
Conflation of Parameter Delivery and Scheduling
Sequencing
Sequencing
Sequencing
Complexity
Complexity
Complexity ii
Complexity
Simplicity vs complexity
Operating System in One Page
Complexity vs. Simplicity
Complexity, Causing Complexity
Complexity, Causing Complexity
Complexity vs Simplicity II
On Building Compilers Multiple Views and Complexity
On Building Compilers Multiple Views and Complexity
ALGOL Bottleneck
ALGOL Bottleneck
The algol bottleneck
Computing
Computing
Computing then and now ii
Computing then and now
New Breed hlls
Programmers vs humans
The primary issue
Twenty milliseconds the magic number
Twenty milliseconds the magic number
Programming redux
What Is A Program?
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
Grok Workbench
Transpilation 101
On Transpilation
Peg
Peg vs. other pattern matchers
Peg vs. other pattern matchers
Regex vs peg
Peg cheat sheet
Racket peg
Parsing vs regexing
Ohminsmallsteps
PEG
PEG
Ohm-JS
PEG vs Lisp Macros
Dlls
Compile time and runtime
Compile Time vs Run Time
Compile Time vs Run Time
Dsl in a day
How to design an scl
Little language
SCN
Notation vs. DSLs and PLs
SCN - Solution Centric Notation
SCN - Solution Centric Notation
Notation
Fbp is no Code for banking apps
Fbp is no Code for banking apps
Html is nocode
No Code
No Code
No Code
Fbp v actors v erlang
The case for fanout
FBP
FBP
Inspiration
S/SL - Syntax Semantic Language
S/SL - Syntax Semantic Language
Inspiration
Inspiration
Erlang v actors
Actors
Actors
Actors
Actors
Mathematics is not reality
Mathematics
Mathematics
Dependent Types
Mathematics vs. Physical Reality
Mathematics vs. Physical Reality
Induction vs recursion
Apl
Kill math
Mathematics redux
Crass simplifications
Two stacks for every type
Typing
Typing
Type stacks
Hierarchical Types
Programming languages are skins
Programming languages are skins
Programming language design
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
PLs (Programming Languages)
PLs (Programming Languages)
The Trouble With UNIX
Two Syntaxes For Each GPL
Two Syntaxes for Every Language
Two Syntaxes for Every 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)
Uncomplicated Programming Languages
Uncomplicated Programming Languages
Control Flow is Orthogonal to Data Structuring
Control Flow is Orthogonal to Data Structuring
Ry vs dry
RY (Repeat Yourself)
RY (Repeat Yourself)
Git could do more
RY - Repeat Yourself as a Programming Language primitive
RY - Repeat Yourself as a Programming Language primitive
Reuse
Architectural archaelogy
Details kill
Architecting, engineering and implementing software
Architecting, engineering and implementing software
Software Architecture
Software Architecture
Comments
Data Cleaving
Code is Cheap
Wish List for Software Architecture
Wish List for Software Architecture
Scalability ii
Dependencies & Scalability
Dependencies & Scalability
Scalability
Scalability
Trees and Crosstalk
Dags and Snippability
Calculators vs. Networks
Functional Programming with Exceptions
Functional Programming with Exceptions
Software Components (Abridged from Flows)
Software Components (Abridged from Flows)
Shuhari
Shuhari
Shuhari
State machine for javascript
State Machines
State Machines
State machines to javascript
Statecharts (again)
Statecharts
StateCharts
StateCharts
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
Software Development
Software Development
Debuggers
Superposition
What if making a compiler was easy?
What if making a compiler was easy?
Holy Grail of Software Development
Holy Grail of Software Development
The stack is a list
The stack 2
The stack
The stack is a global variable (again)
The stack is a global variable (again)
The Stack
The Stack
Superposition
Layered Design
Layered Design
Superposition 2
Fractal design
Dataless programming language
Iterative Design
Nesting and Scoping
Factbases
Factbases 101
FB - Factbases
FB - Factbases
Universal datatype
Triples
Triples
Triples
Testing
Testing
Testing
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
Examples
Examples
ABC Glue
Typed Packet
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
Parsing Diagrams - Bounding Boxes
Parsing Diagrams - Bounding Boxes
Small Example of Interpreting and Compiling
Small Example of Interpreting and Compiling
Techniques
Techniques
Triples in PROLOG
Projectional Editing
Projectional Editing
Projectional editing
Glue Tool
Grasem Tool
Ohm Editor
Tools
Tools
PFR and PF
Various Playlists
Youtube Playlists
Youtube Playlists
Failure Driven Design
FDD - Failure Driven Design
FDD - Failure Driven Design
Lisp
Happy Path (Part 1)
Fdd example workflow
Subdividing problems
Backtracking, mathematics, reversability, garbage collection, time Sharing
Backtracking, mathematics, reversability, garbage collection, time Sharing
Paradigms
Paradigms
First class functions
Clojure
Common Lisp
Common Lisp
Common lisp complexities
Exhaustive search
Prolog vs kanren
Observation why relational programming works
Observation why relational programming works
Relational Programming
Relational Programming
Mutable variables and flags
Pattern Matching
Pattern Matching
Parsing vs fp pattern matching
Parsing vs fp pattern matching
Tokenizing
Isolation
Isolation
Isolation II
Isolation III
Isolation IV
The f**k program
The rain god
Anecdote language learning
Random Anecdotes
Anecdotes
Anecdotes
Building a Language
Anecdote secretary vs. synchrony
Anecdote secretary vs. synchrony
Namespaces
Namespaces Working Paper
Relative namespaces
Relative namespaces
Hierarchical Namedpaces
Lisp 1.5 Memory
Lisp (Frits van der Wateren)
Lisp (Frits van der Wateren)
PLUS Atom Lsip
FP (Functional Programming)
FP (Functional Programming)
Immutability
Type Descriptors (Working Paper
Type Descriptors (Working Paper
Type DSL
Type DSL
Type DSL (SCN)
Case Study - A Language of Types
Case Study - A Language of Types
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)
miscellaneous
miscellaneous
Structured Editing
TORLISP (Toronto Lisp Users Group)
TORLISP (Toronto Lisp Users Group)
Relations
machine readability
machine readability
Readbility
ASON
ASON
ASON: Tokenizing
Indentation to Braces (Case Study)
Indentation to Braces (Case Study)
Markdown for Code
Markdown for Code
Flipping Code
Markdown To Code
Code Markdown to Bash
Code Makdown to Structured Pseudocode
Code Makdown to Structured Pseudocode
Markdown for Design and Implementation (WIP)
Markdown for Design and Implementation (WIP)
ASTs
ASTs
AST Tree
Software Brainstorming
Creativity
Creativity
Brainstorming
Software Creativity
Debugging
Debugging
Are Dynamically-Typed Languages Better For Debugging?
Are Dynamically-Typed Languages Better For Debugging?
Jetbrains MPS
Jetbrains MPS
JetBrains MPS - First Impressions
JetBrains MPS - First Impressions
Jetbrains MPS - Before I Look At It
Jetbrains MPS - Before I Look At It
Compilation
Compilation
Linkers
VMs and JIT
Compilers Are Interpreters
Compilation Is An Optimization
Compilation Is An Optimization
Static Typing Is An Optimization
Static Typing Is An Optimization
White is Black Black is White
Interpreters
Happy Path
Happy Path
Happy Path Culture
Basics
Basics
Basic Circuits
Addressing
Compilers vs. Interpreters
Expressiveness
How All This Stuff Ties Together
How All This Stuff Ties Together
Everything Is Digital
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
The Software Atom
Efficiency
Everything is an interpreter
Efficiency
Efficiency
Peformance
Analysis
Analysis
Quote A
On Designing a DSL
Worlds (comments)
Programming Languages and OSs Not Needed
Programming Languages and OSs Not Needed
Reinventing the Wheel
Reinventing the Wheel
Wheel Reinvention Jam
References
References
References