The wheels that need the most reinventing are our habits based on old biases, e.g. languages and operating systems. The old biases - CPUs are expensive, memory is scarce and expensive - are no longer true.
In this week-long jam (the Wheel Reinvention Jam), I accomplished a lot of what I set out to do (I certainly have not finished and will continue):
- to think about and list the lessons we’ve learned from building GPLs and OSs (General Purpose Programming Languages, and, Operating Systems,resp.)
- to work on concrete tools that were suggested by the lists.
I argue that we should deprecate the notion of GPLs and OSs and free our minds to think of bigger and better ways to control computers.
List Programming The Good Parts
List Programming The Bad Parts
code related to “CALL RETURN Spaghetti”, in JS, in CL, in Python
PE - Architecture Diagram
Free Your Mind
We Don’t Need Programming Languages Nor Operating Systems
Control Flow is Orthogonal to Data Structuring
Concrete Tools + Drawings
pfr grammar-file replacement-script <input-file
- “Parsing” GREP + “parsing sed” (Parsing Find and Replace)
- Based on Ohm-JS
- currently blocked on syntactic silliness, e.g.
await(due to my unfamiliarity with JS) (I welcome help)
- WIP. (Firstclasscomments is an extension of my langjam entry, which shows how to compile diagrams to code).
DLLs can be subsumed by HTTP servers.
Libraries can be subsumed by HTTP servers.
GREP and SED and AWK can be subsumed by something that does better-pattern-matching than simple REGEXPs.
OTOH, REGEXPs can be specified in one line of code, and, anything “better” requires more lines of code.
Ohm-JS (based on PEG) seems like a viable choice for this kind of thing.
Currently, DLLs and libraries are “more efficient” than (localhost) HTTP servers. In fact, the concepts of DLL and library are “optimizations” of the more general concept of “server”. If we replace DLLs and libraries with localhost servers, someone will come up with a way to optimize and speed up localhost servers.
“Build it and they will come”.
DLLs and libraries are merely premature optimizations of a more general concept.
CALL RETURN Spaghetti Code
Architecture Diagram of PE
PE means Programming Environment (a generalization of IDE).
Basically, I argue that everything that is currently “done at compile time” should be done in the PE.
That includes macros, includes, OO inheritance, type checking, syntax checking, like-except, DRY, etc., etc.
Everything else can be done at runtime.
For example, code, dynamic type checking, dynamic object construction (aka Prototype inheritance) can be done at runtime.
Languages are subsumed by the PE.
Code is contained in LEGO®-like Components.
Operating Systems are subsumed by the PE.
Operating Systems are subsumed by CAD-like tools in the PE for plumbing Components together. For example, if an app needs input from the keyboard, we plug a keyboard Component into the app (via the PE). If the app needs input from a mouse, we plug a mouse Component into the app (via the PE). If an app needs to handle files, we plug a file system Component into the app. And so on.
I wrote my “thinking” and notes in Scrivener.
Below, I include screenshots of the outlines…
The originals can be found in github wheel reinvention.
Programming - The Good Parts
Programming - The Bad Parts
There is only one thing that matters:
1. controlling machines1
We resort to things that we call:
Programming languages are merely syntactic sugar for the above.
Can we create a toolbox of paradigms, then drape syntactic sugar over the paradigms?
The concept of programming languages, especially GPLs (General Purpose Languages), should be deprecated.
GPLs are obviated by Ohm-JS(PEG)-based notations.
OSs are merely glorified libraries (which can be obviated by using better library technology (e.g. LEGO®-like blocks).
There are many other biases, such as
- the idea that GPLs (General Purpose Programming Languages) must be based on grids of non-overlapping bitmaps (aka Characters, Text).
- 2D notation.
Until now, we had only paper (pencil-and-paper) to use when evolving ideas.
Now, we have 3D workstations.
Machines that we call “computers”. ↩