Make software simple again

• https://ics.uci.edu/~fielding/pubs/dissertation/top.htm

Roy Fielding's disseration on the design of networked applications and RESTful architecture. Gives context to the design of modern hypermedia systems, HTTP, the web and applications we build on top of it.

• https://htmx.org/docs/

Library that implements a modern hypermedia client in any web browser, rather than writing a different one every time you make a webapp.

• https://nextjournal.com/mk/rich-hickey-on-repls

REPLs aren't just about evaluating code interactively, they're a well-defined entrypoint for the programmer to modify and inspect a system. The ceremony is well-organized and specifically tailored to this purpose, you send data to the program, the program evaluates it, and you get data back. Also see the linked talk by Nada Amin, which evaluates this concept from the perspective of implementing languages.

• https://www.youtube.com/watch?v=1ZTRb-2DZGs
• https://justine.lol/cosmopolitan/index.html
• https://redbean.dev/

Cosmo is a gargantuan effort to create a C library that can target multiple platforms at once in a single binary. It has one abstraction over the system layer that largely emulates the amd64 ABI for Linux, meaning that most applications made for Linux can run natively on any major operating system. It also bundles necessary functions for common tasks like HTTP servers or multimedia manipulation. Redbean is a small application server linked against cosmo that provides the equivalent of a full LAMP stack in one program, one executable file that is your entire application, with its code and database state.

• https://www.ultratechnology.com/meta.html#minmeta
• https://arduino-forth.com/article/FORTH_metacompilation_intro
• https://pygmy.utoh.org/pygmyforth.html

Forth is a very small programming language, phrased more as an abstract stack machine. The machine executes words, which are procedures that manipulate data on a shared stack. Typically the machine is defined in terms of primitive words, implemented in native machine code. Forth metacompilers allow for this abstract machine to be defined in Forth itself, creating a very tight loop for designing other Forth systems.

• https://pygmy.utoh.org/3ins4th.html

From Frank Sergeant. Essentially describes a generic protocol for a machine code monitor over a serial port. Using only peek, poke, and essentially a CALL instruction, a full Forth machine can be implemented on the target from any programming language.

• https://youtu.be/uknEhXyZgsg?si=69rb8E0Lljtr-w1E
• https://computerhistory.org/blog/smalltalk-at-50/

• https://www.youtube.com/watch?v=2K1C5BZKP3I

• https://selflanguage.org/

Self was the breeding ground for what eventually became the JVM platform and Javascript's prototypal object system. It was a pioneer in language VM implementation, aiming to create an entire development environment and runtime in the same programming language.

• https://www.youtube.com/watch?v=gV5obrYaogU

A complete 3D and compositing solution all running on a Symbolics Lisp Machine. Later became the software basis for SGI and its many licensed development kits.

• https://www.sbcl.org/porting.html

Common Lisp implementation written in itself, build process can almost skip a C compiler.

• https://en.wikipedia.org/wiki/Oberon_(operating_system)
• https://www.youtube.com/watch?v=OJGnpmnXR5w

A complete operating system implemented in a Pascal-like language. All interactions with the system are done thru rich text documents that can embed programs and various objects. Running code is as simple as clicking a hyperlink.

• https://youtu.be/7RNbIEJvjUA?si=rYcdjt8D22oHGokS&t=1505
• https://en.wikipedia.org/wiki/BTRON

A core component of Japan's TRON computer platform, was meant to be a programming environment working on the scale of the web. All resources were presented as inspectable objects, much like Smalltalk. These could represent simple data, hypermedia documents, remote machines, or collections of other objects.

• http://www.rebol.com/what-rebol.html

• https://pygmy.utoh.org/pygmyforth.html

A complete Forth system for DOS that can recompile itself. Includes facilities for interactive development and debugging.

• https://dacvs.neocities.org/SF/
• https://www.youtube.com/watch?v=9MSJGzYELBA

A Forth 2012 compliant system implemented in legible amd64 machine code. The interpreter bootstraps from a byte-delimited read-protocol, which defines the primitive Forth words directly in machine code. After startup, a full Forth system can be used to compile and run code interactively.

• https://github.com/nornagon/jonesforth/blob/master/jonesforth.S

Forth implemented in x86 assembler, complete with inline documentation and diagrams explaining how it works.

• https://www.graalvm.org/latest/reference-manual/java-on-truffle/

• https://stackoverflow.com/a/53057494
• https://www.linuxboot.org/

• https://www.youtube.com/watch?v=8Ab3ArE8W3s

• https://youtu.be/L9v4Mg8wi4U

• https://dercuano.github.io/notes/powerful-primitives.html