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

Image

Links

Recursive Design

Recursive Design

Divide and conquer 

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

API Takeaways

Thinking is Hard, Coding is Easy

Thinking is Hard, Coding is Easy

WASM Transpiler Example

WASM Transpiler Example

Compiler Technology Takeaways 3

Compiler Technology Takeaways 3

Diagram Conventions

Diagram Conventions

DRY vs. RY

DRY vs. RY

Refactoring

Refactoring

Compiler Technology Takeaways

Compiler Technology Takeaways

Data Descriptors Takeaways

Data Descriptors Takeaways

Functional programming vs parsing

Functional programming vs parsing

First Class Functions - Takeaways

First Class Functions - Takeaways

Dataless Language

Dataless Language

Functional Programming - Takeaways

Functional Programming - Takeaways

Denotational Semantics Takeaways

Denotational Semantics Takeaways

Java Takeaways

Java Takeaways

Diagram Notation

Diagram Notation

Less Code

Less Code

Layers

Layers

Lisp Takeaways

Lisp Takeaways

Normalization

Normalization

Object Oriented Takeaways

Object Oriented Takeaways

Pattern Matching Takeaways

Pattern Matching Takeaways

Relational Programming Takeaways

Relational Programming Takeaways

Ssl takeaways

Ssl takeaways

Scalability 2

Scalability 2

Takeaways

Takeaways

(Programming - The Good Parts)

Data Design vs Control Flow Design

Data Design vs Control Flow Design

Business Takeaways

Business Takeaways

Agile Takeaways

Agile Takeaways

Construction Industry Takeaways

Construction Industry Takeaways

Waterfall Takeaways

Waterfall Takeaways

Scalability Takeaways

Scalability Takeaways

Structured Programming Takeaways

Structured Programming Takeaways

UNIX Takeaways 2

UNIX Takeaways 2

UNIX Takeaways

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

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

Connecting Layers

Software Components

Software Components

5 whys of software components 

5 whys of software components 

Filereader 

Filereader 

Html components arrowgrams 

Html components arrowgrams 

Components (again) 

Components (again) 

Indirect calls 

Indirect calls 

Component diagrams 

Component diagrams 

Need to know 

Need to know 

Patterns 

Patterns 

Aynchronous Components Design Note

Aynchronous Components Design Note

The Atomic API

The Atomic API

Flows

Flows

ASC (Working Paper)

ASC (Working Paper)

Flows (Abridged)

Flows (Abridged)

Functions Are Not ASCs

Functions Are Not ASCs

Message Loops vs. Recursion

Message Loops vs. Recursion

The Bare Essence

The Bare Essence

Communicating State Machines

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 

Programming 

The Big Red Button

The Big Red Button

META

META

Introduction 

Introduction 

Table of Contents May 24

Table of Contents May 24

Table of Conents May  13

Table of Conents May  13

DI - Design Intent

DI - Design Intent

Di design intent 

Di design intent 

DI - Design Intent 

DI - Design Intent 

Elements of DI (WIP)

Elements of DI (WIP)

Elements of a DI Drawing (WIP)

Elements of a DI Drawing (WIP)

Design Intent Lanuguage

Design Intent Lanuguage

DaS

DaS

Parsing Diagrams

Parsing Diagrams

Compiling Diagrams To Code

Compiling Diagrams To Code

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

Transpiling diagrams overview 

Restricted thinking programming editors 

Restricted thinking programming editors 

Parsing and compiling diagrams 

Parsing and compiling diagrams 

Editor for gratoms 

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 

Processes are state machines 

Compiling diagrams 2 

Compiling diagrams 2 

Breaking free of the cell paradigm 

Breaking free of the cell paradigm 

Syntax Primitives 

Syntax Primitives 

Compiling Diagrams 

Compiling Diagrams 

Diagram based languages 

Diagram based languages 

Programmers’ UX

Programmers’ UX

Structured Design as Diagrams

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

Transpiling Diagrams to Bash

Visual Programming

Visual Programming

Arrowgrams

Arrowgrams

Curse of the editor 

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 

Call return spaghetti 

Concurrency is a paradigm 

Concurrency is a paradigm 

Javascript concurrency 

Javascript concurrency 

Multitasking is easy 

Multitasking is easy 

5 whys of full preemption 

5 whys of full preemption 

5 whys of multiprocessing 

5 whys of multiprocessing 

Sequencing 

Sequencing 

Concurrency bare bones 

Concurrency bare bones 

Html components handling callback logic explicitly 

Html components handling callback logic explicitly 

The problem 

The problem 

Blocking 

Blocking 

Breaking out of synchronous thinking 

Breaking out of synchronous thinking 

Breaking long running loops 

Breaking long running loops 

Multitasking Faking

Multitasking Faking

Asynchronous Thinking

Asynchronous Thinking

CALL RETURN

CALL RETURN

Call return spaghetti 

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 

Sequencing 

Complexity

Complexity

Complexity 

Complexity 

Complexity ii 

Complexity ii 

Simplicity vs complexity 

Simplicity vs complexity 

Complexity vs. Simplicity

Complexity vs. Simplicity

Complexity, Causing Complexity

Complexity, Causing Complexity

Operating System in One Page

Operating System in One Page

ALGOL Bottleneck

ALGOL Bottleneck

The algol bottleneck 

The algol bottleneck 

Computing

Computing

What Is A Program?

What Is A Program?

Computing then and now 

Computing then and now 

Computing then and now ii 

Computing then and now ii 

New Breed hlls 

New Breed hlls 

Programmers vs humans 

Programmers vs humans 

The primary issue 

The primary issue 

Twenty milliseconds the magic number 

Twenty milliseconds the magic number 

Programming redux 

Programming redux 

IoT

IoT

PROLOG

PROLOG

Scheme to javascript 

Scheme to javascript 

Transpilers

Transpilers

Dsl manifesto 

Dsl manifesto 

Scanning and parsing overview 

Scanning and parsing overview 

Toolbox languages 

Toolbox languages 

Svg grammar 

Svg grammar 

Learning about compilers quickly 

Learning about compilers quickly 

Scls little languages playlist 

Scls little languages playlist 

Toolbox languages (2) 

Toolbox languages (2) 

Transpilation

Transpilation

Transpilation 101

Transpilation 101

Grok Workbench

Grok Workbench

PEG

PEG

Peg 

Peg 

Ohminsmallsteps 

Ohminsmallsteps 

Ohm-JS

Ohm-JS

PEG vs Lisp Macros

PEG vs Lisp Macros

Parsing vs regexing 

Parsing vs regexing 

Racket peg 

Racket peg 

Peg cheat sheet 

Peg cheat sheet 

Regex vs peg 

Regex vs peg 

Peg vs. other pattern matchers 

Peg vs. other pattern matchers 

Efficiency

Efficiency

Efficiency 

Efficiency 

Everything is an interpreter 

Everything is an interpreter 

Compile Time vs Run Time

Compile Time vs Run Time

Dlls 

Dlls 

Compile time and runtime 

Compile time and runtime 

SCN - Solution Centric Notation

SCN - Solution Centric Notation

Notation

Notation

Dsl in a day 

Dsl in a day 

How to design an scl 

How to design an scl 

Little language 

Little language 

SCN 

SCN 

Notation vs. DSLs and PLs 

Notation vs. DSLs and PLs 

No Code

No Code

No Code 

No Code 

Fbp is no Code for banking apps 

Fbp is no Code for banking apps 

Html is nocode 

Html is nocode 

FBP

FBP

Fbp v actors v erlang 

Fbp v actors v erlang 

The case for fanout 

The case for fanout 

Actors

Actors

Actors

Actors

Actors 

Actors 

Erlang v actors 

Erlang v actors 

Inspiration

Inspiration

S/SL - Syntax Semantic Language 

S/SL - Syntax Semantic Language 

Inspiration 

Inspiration 

Mathematics

Mathematics

Mathematics is not reality 

Mathematics is not reality 

Induction vs recursion 

Induction vs recursion 

Apl 

Apl 

Kill math 

Kill math 

Mathematics redux 

Mathematics redux 

Crass simplifications 

Crass simplifications 

Dependent Types

Dependent Types

Mathematics vs. Physical Reality

Mathematics vs. Physical Reality

Typing

Typing

Two stacks for every type 

Two stacks for every type 

Type stacks 

Type stacks 

Hierarchical  Types

Hierarchical  Types

PLs (Programming Languages)

PLs (Programming Languages)

Programming language design 

Programming language design 

Programming languages are skins 

Programming languages are skins 

Variable names not needed 

Variable names not needed 

Divide and conquer in pls 

Divide and conquer in pls 

Asking the right questions 

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 

Txl 

Breaking long running loops 

Breaking long running loops 

Tags instead of names 

Tags instead of names 

PLD vs PLF (notes)

PLD vs PLF (notes)

The Trouble With UNIX

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 

Git could do more 

Ry vs dry 

Ry vs dry 

Software Architecture

Software Architecture

Comments

Comments

Reuse 

Reuse 

Architectural archaelogy 

Architectural archaelogy 

Details kill 

Details kill 

Architecting, engineering and implementing software 

Architecting, engineering and implementing software 

Data Cleaving

Data Cleaving

Code is Cheap

Code is Cheap

Wish List for Software Architecture

Wish List for Software Architecture

Dependencies & Scalability

Dependencies & Scalability

Scalability 

Scalability 

Scalability ii 

Scalability ii 

Trees and Crosstalk

Trees and Crosstalk

Dags and Snippability

Dags and Snippability

Calculators vs. Networks

Calculators vs. Networks

Functional Programming with Exceptions

Functional Programming with Exceptions

Scalability

Scalability

Software Components (Abridged from Flows)

Software Components (Abridged from Flows)

References

References

References 

References 

Shuhari

Shuhari

Shuhari 

Shuhari 

State Machines

State Machines

State machine for javascript 

State machine for javascript 

State machines to javascript 

State machines to javascript 

StateCharts

StateCharts

Statecharts 

Statecharts 

Statecharts (again) 

Statecharts (again) 

Software Development

Software Development

Software development roles 

Software development roles 

Refactoring 

Refactoring 

Software ceiling 

Software ceiling 

Apple® refunded my money because of a bug 

Apple® refunded my money because of a bug 

Sofware kleenex® 

Sofware kleenex® 

Miscellaneous 

Miscellaneous 

Pure research vs applied research 

Pure research vs applied research 

What is programming 

What is programming 

One in how many out? 

One in how many out? 

How many inputs vs how many outputs? 

How many inputs vs how many outputs? 

Divide and conquer yagni 

Divide and conquer yagni 

Toe for software development 

Toe for software development 

Dynamic anything is bad 

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 

Superposition 

The Stack

The Stack

The stack is a list 

The stack is a list 

The stack 2 

The stack 2 

The stack 

The stack 

The stack is a global variable (again) 

The stack is a global variable (again) 

Layered Design

Layered Design

Superposition 

Superposition 

Superposition 2 

Superposition 2 

Fractal design 

Fractal design 

Dataless programming language 

Dataless programming language 

Nesting and Scoping

Nesting and Scoping

FB - Factbases

FB - Factbases

Factbases 

Factbases 

Factbases 101 

Factbases 101 

Triples

Triples

Triples 

Triples 

Universal datatype 

Universal datatype 

Testing 

Testing 

Examples

Examples

Glue manual 

Glue manual 

Svg to code (1) 

Svg to code (1) 

Notation Example 

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

ABC Glue

Small Example of Interpreting and Compiling

Small Example of Interpreting and Compiling

Techniques

Techniques

Bootstrapping 

Bootstrapping 

Cps considered to be a goto 

Cps considered to be a goto 

Message passing 

Message passing 

State, analysis of 

State, analysis of 

Meta Programming 

Meta Programming 

Incompleteness 

Incompleteness 

Scoping static vs dynamic 

Scoping static vs dynamic 

Function or list? 

Function or list? 

Relational programming and the kitchen sink 

Relational programming and the kitchen sink 

Regex 

Regex 

Projectional Editing

Projectional Editing

Projectional editing 

Projectional editing 

Tools

Tools

Glue Tool 

Glue Tool 

Grasem Tool 

Grasem Tool 

Ohm Editor 

Ohm Editor 

Youtube Playlists

Youtube Playlists

Various Playlists 

Various Playlists 

FDD - Failure Driven Design

FDD - Failure Driven Design

Failure Driven Design 

Failure Driven Design 

Fdd example workflow 

Fdd example workflow 

Subdividing problems 

Subdividing problems 

Lisp

Lisp

Happy Path (Part 1)

Happy Path (Part 1)

Paradigms

Paradigms

First class functions 

First class functions 

Clojure 

Clojure 

Backtracking, mathematics, reversability, garbage collection, time Sharing 

Backtracking, mathematics, reversability, garbage collection, time Sharing 

Common Lisp

Common Lisp

Common lisp complexities 

Common lisp complexities 

Relational Programming

Relational Programming

Exhaustive search 

Exhaustive search 

Prolog vs kanren 

Prolog vs kanren 

Observation why relational programming works 

Observation why relational programming works 

Pattern Matching

Pattern Matching

Mutable variables and flags 

Mutable variables and flags 

Parsing vs fp pattern matching 

Parsing vs fp pattern matching 

Isolation

Isolation

Tokenizing 

Tokenizing 

Isolation  II

Isolation  II

Isolation III

Isolation III

Isolation IV

Isolation IV

Anecdotes

Anecdotes

Anecdote secretary vs. synchrony 

Anecdote secretary vs. synchrony 

Building a Language

Building a Language

The f**k program 

The f**k program 

The rain god 

The rain god 

Anecdote language learning

Anecdote language learning

Random Anecdotes 

Random Anecdotes 

Relative namespaces

Relative namespaces

Hierarchical Namedpaces

Hierarchical Namedpaces

Namespaces

Namespaces

Namespaces Working Paper

Namespaces Working Paper

Lisp (Frits van der Wateren)

Lisp (Frits van der Wateren)

Lisp 1.5 Memory

Lisp 1.5 Memory

PLUS Atom Lsip

PLUS Atom Lsip

FP (Functional Programming)

FP (Functional Programming)

Immutability

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)

Type DSL (SCN)

miscellaneous

miscellaneous

Status

Status

Structured Editing

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

Readbility

Relations

Relations

ASON

ASON

ASON: Tokenizing

ASON: Tokenizing

Markdown for Code

Markdown for Code

Indentation to Braces (Case Study)

Indentation to Braces (Case Study)

Flipping Code

Flipping Code

Markdown To 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

Code Markdown to Bash

ASTs

ASTs

AST Tree

AST Tree

Creativity

Creativity

Software Creativity

Software Creativity

Brainstorming

Brainstorming

Software 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

Happy Path Culture

Basics

Basics

Basic Circuits

Basic Circuits

Addressing

Addressing

Compilers vs. Interpreters

Compilers vs. Interpreters

Everything Is Digital

Everything Is Digital

Expressiveness

Expressiveness

How All This Stuff Ties Together

How All This Stuff Ties Together

Exercises

Exercises

Langjam Suggestion

Langjam Suggestion

SCN Development for Zodetrip

SCN Development for Zodetrip

Exercise Writing A Simple Interpreter

Exercise Writing A Simple Interpreter

Game Development

Game Development

Keying For Zodetrip

Keying For Zodetrip

Macros

Macros

Racket Macros

Racket Macros

Racket Macros (2)

Racket Macros (2)

Racket Switch Macro

Racket Switch Macro

Racket Peg Case Forms

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

The Software Atom