REPLs & tamsyn & bytes, oh my! @millihertz@oldbytes.space

say what you like about Soviet Russia, nobody in the west looked at the PDP-11 and thought "hey, we could make a home computer out of this!" - even though, you know, they definitely could have done

https://en.wikipedia.org/wiki/Electronika_BK
https://en.wikipedia.org/wiki/UKNC

i wish i'd picked up (and been able to afford) an Amiga 600 when they were new. not so much because i have any particular Commodore allegiance, but because i just love the way they look... even more so than the 500 or 1200, i think they're easily the cutest of the Amigas

it's always... something - what's that feeling exactly midway between amusing and horrifying? - when someone decides to bolster their old 8 bit machine with an ESP32-based widget. like, "how much more computational power have you just added onto this thing's bus than it has itself?"

especially for something like a ZX81, where the ESP32 could run a complete emulation of it and still have (lots of) cycles to spare (though i'd rather see what someone could do implementing Sinclair-ish BASIC directly on the ESP32 tbh)

everyone knows about Agner Fog, right? https://www.agner.org/optimize/#manuals

at some point he's going to have to start doing the same for ARM cores... that'd be useful information!

speaking of bad magic:

qjs > print [1,2,3]+[4,5,6]
"undefined4,5,6"
qjs > print( [1,2,3]+[4,5,6] )
"1,2,34,5,6"
undefined
qjs > a = [1,2,3]; print a + [4,5,6]
SyntaxError: expecting ';'
    at <evalScript>:1
qjs > a = [1,2,3]; print( a + [4,5,6] )
"1,2,34,5,6"
undefined

two questions: what's so fundamentally different about the third one, as opposed to the first? and where did the side effect of print go in the first one?

and that's why the halting problem is so formulated. what it does is perfectly reasonable: it halts on a program containing an infinite loop, and goes off into an infinite loop on a program that doesn't. it's general: it can be fed any program (specifically, any Turing machine's input tape). and if the mathematical system were complete, it would be decidable, even given its rather strange result conditions.

but of course, it isn't, and that's easily demonstrated by feeding it its own input tape.

it absolutely doesn't mean that it's impossible to detect infinite loops in programs. it means something much broader and more fundamental than that. it means that mathematics, as a whole, cannot be considered complete, because it can express problems that it cannot decide.

two other mathematicians approached the same question in different ways at the same time. Alonzo Church formulated the lambda calculus. the other was a fellow you might have heard of, called Kurt Gödel.

everyone misunderstands the halting problem

it's not a demonstration that you can't make a program that determines whether there aren't any infinite loops in the program input to it. that's easily resolved: propose a program that never goes into an infinite loop, whatever is fed to it, and feed it to itself. no contradiction.

the precise formulation of the halting problem - that whatever the program it is given does, the checker program does the opposite - is vitally important, which gives you a hint as to what it really means. it means - and this is what Turing intended it to mean - that there exist some problems that are intriniscally uncomputable. and Turing's interest at this point was not so much in computation, but in determining whether or not any mathematical system could be complete. his Turing machines were a thought experiment of a system which could compute any computable problem - essentially the simplest possible potentially-complete system.

so contradictions glare. →

seems to me that the problem with any programming language is the strangeness of its magic

Javascript, apparently, has a lot of magic, all following its own unalterable (but somehow poorly-defined) rules. so do Perl and PHP

C++ lets you write your own magic... to a point

Forth and Lisp don't have magic at all. they have nuclear technology ;-)

one of the more delightful(/s) things about the Z80 is the fact that POP xx takes fewer cycles than INC SP; INC SP

you have to stare long and hard to wonder how that happened.

(the 8080 executes them in the same time, 10 cycles, but POP is still a byte shorter)

if your editor doesn't use vi, emacs, CUA or Wordstar (or at the outside, Brief) command bindings, and it can't easily be configured to, then why?!

ooh, my first edit notification!

well, not mine. a toot that i boosted.

re LB: and let's not forget, the readability of assembly language