Now I feel old. I know void from K&R C and iota from APL

A lot of the work being done here by the program code was done in dynamically linked libraries in the original game.

This is similar `Resume Next` in VB

Where do I find the implementation of int 0x16 and int 0x10?

The First Computers

History and Architectures

Edited by Raúl Rojas and Ulf Hashagen

https://mitpress.mit.edu/9780262681377/the-first-computers/

Wouldn't it be better to put SQL statements in stored procedures rather than dynamically loaded text files?

There's plenty of queries you may find yourself scattering throughout your application that you don't want to have in the database as a stored procedure, if for no other reason than it being overkill and extra work.

If it's business logic in the query that might get re-used across independent applications (e.g., cancelling an order), then I would think a stored procedure is better. But if it's specific to that application (e.g., fetching title+description+publication date of the five most recent blog entries for a side panel), I wouldn't care to put that in the db as a stored procedure.

I agree. 68k was one of the most orthogonal architectures ever.

After the PDP-11 architecture, yes.

well except for the two sorts of registers

Three, starting with 68040.

And likely far more by now, had it become the PC instruction set architecture. The x86 instruction set was also simpler back in the late 70s, in the 8086 era when the Motorola 68000 was first released, than it is now.

Back then it only had the one register width (16-bit, e.g. "ax"), whereas now it has the 32-bit series (e.g. "eax") series and the 64-bit series (e.g. "rax"). It also now has SIMD, SSE/AVX, virtualization support, and other technologies. Back then it just had one operating mode (real mode), whereas now it has protected mode, long mode, system management mode, and a few other intermediate modes (e.g. "unreal mode").

So a lot of the complexity that x86 has now was introduced after that decision was made. It's definitely conceivable that the 68000 line would have developed similarly had it been chosen instead of x86 for the PC.

8086 let you address the upper and lower halves of the 16-bit registers as well, so don't trick yourself into thinking there was just one register width available in the sense that everything could only be treated as 16-bit words.

Many 8 bit processors had the same “feature”. For example, the Z80’s 8 bit registers were internally just halves of a 16 bit register.

In the `logNow` example, the date argument will be eager evaluated, not lazzy evaluated. Am I right? So what was supposed to be a real use case doesn't seem useful to me.

Nice catch. Rather than date the author should've pass the DEBUG constant instead.

Or a function that return new date, but it'll make things complicated.

However , to pass a constant I could use default parameter value.

It's the function definition that's responsible for defining default parameter.

It's the function caller that's responsible for that parameter with partial application / currying / closure.

It doesn't matter if you develop both, but if you use a library you'll need partial application to define default parameter.

The equivalent in Visul Basic would be:

On Error Goto line

Or in Pascal

   try
     ...
   except
   end

wrapped around the error/exception generating code

Deserves an upvote. Not everyday you see praise about Visual Basic.

Looked this up and line can also be a label. Great.

A game with this UI and Voronoi diagram rules would be fun.

https://en.m.wikipedia.org/wiki/Voronoi_diagram