Smalltalk VS jonesforth

> * I'm assuming the "by the Bluebook" implementation they're referring to is this: *

Or this: https://github.com/rochus-keller/Smalltalk/

> message passing and late binding combined. "Duck typing" is seriously diminishing it

Actually even ST-72 made synchronous calls, but at least with a token stream interpreted by the receiving object (thus at least a bit of "message passing"). In ST-76 and later versions "message passing" is just nomenclature used by the ST folks for something that is just ordinary method dispatch and call (if you have doubts, you can analyze the innards of the ST-80 VM yourself e.g. with these tools: https://github.com/rochus-keller/Smalltalk ). The major difference is the dispatch based on signature hash (similar to e.g. Java interface method calls) instead of static positions, which enables late binding (at the expense of performance); and since everything including ordinary integers derive from Object, all values and objects are subject to dynamic method dispatch; it's no coincidence that Smalltalk was the first language to allow real duck typing. The unification of scalar values and references, dynamic typing, and likewise the minimal syntax where control structures are implemented by means of runtime constructs were already known from Lisp; also closures (i.e. ST blocks) were already known before they were added to ST.

Here is one even in Lua: https://github.com/rochus-keller/Smalltalk/

> 10kSLOC for the entire universe

It is the nature of idealists that they see the world idealized. Smalltalk-80 itself has nearly 30 kSLOC; it's just more difficult to count, but I wrote tools which can do it (https://github.com/rochus-keller/Smalltalk/).

Why should "perform" be a message? It's just a method of the Object class, which is the superclass of Integer. You can use my St80ClassBrowser and St80ImageViewer (see https://github.com/rochus-keller/Smalltalk/) to check the ST-80 source code and image if you want; there is a list of all selectors and the classes which implement them. Going up the class hierarchy when doing virtual method dispatch is a fundamental concept of all object-oriented implementations; in contrast to e.g. C++ this can be done dynamically at runtime in Smalltalk or Java (which is also called late binding). In contrast to Smalltalk in Java the class loader verifies that a method for the referenced signature actually exists; in Smalltalk you can try to dispatch any signature which can result in a call to the doesNotUnderstand method of the Object class.

> a large lua game code base, over 4000 files, 1.5 million lines of code

Interesting; how do you manage to keep consistency? Do you have special tools to e.g. detect inadvertent global variables? I once wrote a Smalltalk VM in Lua (https://github.com/rochus-keller/Smalltalk/blob/master/Inter...) which is a much smaller code base but even with this size I quickly would have lost track of e.g. scopes and names without tools I had to write myself (https://github.com/rochus-keller/LJTools).

It is true, that there is uncollected garbage in the original Xerox ST80 image. I've built some tools to analyze the image and also a VM which can be interrupted at any time to analyze the current state of the image (see https://github.com/rochus-keller/Smalltalk).

There are two zombie processes (OID 6662 and 19ba). There are also a couple of BlockContext and MethodContext which have a nil sender and a reference to an unknown method, but which are still referenced from somewhere (i.e. the collection is prevented even if it is not implemented by reference counting. E.g. OID 79a2 of class BinaryChoice. I have a full list if anybody is interested.

Integers are actually directly stored, i.e. without boxing/indirection by a pointer. The Smalltalk object memory doesn't have pointers in the C sense, but rather indices into the object table. If you're interested I've implemented a couple of tools to study the original Smalltalk-80 VM, see https://github.com/rochus-keller/Smalltalk/.

- https://github.com/rochus-keller/Smalltalk/ Parser, code model, interpreter and navigable browser for the original Xerox Smalltalk-80 v2 sources and virtual image file

- https://github.com/rochus-keller/Som/ Parser, code model, navigable browser and VM for the SOM Smalltalk dialect

- https://github.com/rochus-keller/Simula A Simula 67 parser written in C++ and Qt

> do you regret those endeavours?

No, not in any way; the projects were very entertaining and gave me interesting insights.

Cool. Here are some other resources that I've encountered along the way of learning Forth:

- JonesForth: https://github.com/nornagon/jonesforth/blob/master/jonesfort...

This is legit a text that goes the an x86 Forth implementation. Actually, it's just an implementation with really extensive comments. That said, including whitespace and comments, it's just 2000 lines and the pedagogy is excellent. Highly recommended for anyone who would rather see behind the curtain before picking up a larger text.

- SmithForth: https://dacvs.neocities.org/SF/

So, Smith decided to hand-write a Forth directly in x86-64 opcodes (well, the corresponding ascii hex bytes). It's incredibly slim and enlightening how you can bootstrap a language in just a couple hundred bytes or so.

This project actually inspired me to really learn the x86-64 architecture, so I ended up hand-decompiling the SmithForth binary instead of going through his commented implementation. Hand-decompilation is an absolutely fascinating exercise. You learn all about ELF structure, opcode encodings, and actually start to see the gaps where microarchitectural details shine through. Highly recommended for any hacker that really wants to grok low level details.

- Mecrisp: https://mecrisp.sourceforge.net/

An amazingly fast Forth implementation for MSP430, ARM, RISC-V, MIPS, and some FPGAs. This gave me one really nice understanding of Forth as

    A REPL into your hardware!

I've git-cloned JonesFORTH (https://github.com/nornagon/jonesforth/blob/master/jonesforth.S) and achieved to compile it (i.e. run make w/o an error. When I start the executable, it presents me with an empty line, and when I say BYE, it says PARSE ERROR: bye.

Is there any particular language you're looking for? I've found some languages hideous until I understood them and could appreciate their respective graces. Off the top of my head the I can think of a couple.

The first is Jones Forth (https://github.com/nornagon/jonesforth), start with jonesforth.S and move into jonesforth.f. I really enjoyed following along with it and trying my hand at making my own stack based language.

The other is Xv6, a teaching operating system from MIT (https://pdos.csail.mit.edu/6.828/2021/xv6.html), not all the code or implementations are top notch but it shows you non-optimized versions (just because they're simple and more readable) of different concepts used in OS design.

If you're interested in the embedded world, there is a really neat project I've been following that feels a more structured and safe (as in fault-tolerant) while still staying pretty simple (both conceptually and in the code itself): Hubris and Humility (https://hubris.oxide.computer/).

Very low hardware requirements, so basic industrial control at the level where you'd otherwise use an Arduino or so but on scavenged hardware. Forth is ridiculously simple to get an implementation running.

https://github.com/nornagon/jonesforth/blob/master/jonesfort...

Is a nice starting point. It's obviously not as compact as say 'Brainfuck' but it is far more versatile.

OP mentioned jonesforth, but linked to a nasm port of it. Which is probably good it’s just that the documentation in the comments with ascii art doesn’t look right on my screen. So here’s a more common repo: https://github.com/nornagon/jonesforth

Rip the asm macros for the basic FORTH words out of this and then embed them in a C binary, statically linked with your favourite libs for whatever task. Although I haven't tried this yet, I'm planning on doing it with ncurses for my own Roguelike. From there, if you can convert the function calls and your parameters down to raw numbers, you can send instructions to ncurses or whatever other API you like, directly from a FORTH stack.

or the mirror of this site in github: https://github.com/nornagon/jonesforth