Posts
-
Static Typing Is An Optimization
-
Lisp
-
Compilation Is An Optimization
-
Diagram Parsing - Bounding Boxes
-
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
-
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