Conversation

Notices

1. Embed this notice
   Charlie Stross (cstross@wandering.shop)'s status on Friday, 31-Oct-2025 20:52:13 JST Charlie Stross

   Would be even better if it turned out that (a) yes, and (b) meanwhile, AWS are hosting their BGP tables on MS Azure ...!
   https://mastodon.social/@otolithe/115459389479814793

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Friday, 31-Oct-2025 20:52:11 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor Sorta like recompiling the whole system. You need a system to compile the system, and they need to be similar enough.

     Then to boot you need to have a file server anyway ...

     Mmm.. Lisp Machine.

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Friday, 31-Oct-2025 20:52:12 JST Weekend Editor

     in reply to

     @cstross

     I once saw something almost exactly like this.

     It was at Symbolics (lisp machines) back in the 80s. We had a machine configured to be a file server, and another to be a namespace server. ("Namespace" was what we called the equivalent of DNS in the lisp machine world, probably before DNS existed or at least before it became popular.)

     Somebody put the namespace server's data files on the file server, because hey, it's for storing files, right?

     Things went swimmingly until there was a power cut.

     Then it was deduced that there was no feasible boot order:
     - The file server needed namespace service to figure out who it was.
     - The namespace server needed file service to get at the files containing its data.

     It was... "interesting".

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Thursday, 27-Nov-2025 21:00:48 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor Not that simple, specially if you moved lots of things in the System Areas, QFASL changes, and or dropped a bit here or there in the DTP fields.

     The two systems need to be very, very, very similar for this to work. 🙂

     Both on the Lisp side, but also on the QFASL side.

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Thursday, 27-Nov-2025 21:00:49 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     That one, we could solve. Use the compiler on a previous system to compile sources to binaries in the usual way. Build a cold load from those compiler-generated binary files. Then boot the cold load and use it to load in the rest of the system, and save a world load.

     This usually took several days, requiring deep debugging of all the dependencies that had inevitably crept in. The folk who did it at Symbolics were called "Wobblies", after the labor union IWW: International Workers of the World.

     Meta-point the function (qld) for more. Pretty sure it'll be even in the MIT branch of lispm software you have, since it dates from the time before Symbolics & LMI.

     Edited to add: it occured to me too late that you probably already know this, having built MIT-derived world loads yourself! Sorry, didn't mean to sound patronizing.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Thursday, 27-Nov-2025 21:03:09 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor E.g., System 78 to System 98/99 would be more or less impossible. The Lisp Machine Lisp language evolved, the 25-bit change, QFASL aren't compatible.

     So you'd need to backport the compiler, then also figure out how to almost cross compile things .. and you'd need to figure out how to recompile everything which means having to load lots of things.. Which means running things from an incompatible system.

     Fun fun fun fun for the whole family!

     @cstross

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Friday, 28-Nov-2025 00:23:45 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor Yeah. The advent of cross compilers in Lisp Machine history was .. late.

     I've been toying with the idea to hack the Lisp Machine compiler to do cross compilation .. but it is all a ball of goo...

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Friday, 28-Nov-2025 00:23:47 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     There were at least a couple instances like that at Symbolics, which I remember.

     In one, we changed the .BIN file format (which which in turn was changed from the .QFASL format on the LM-2/CADR). That required the compiler to be hacked to generate binaries for the world being built, in the fashion of cross-compilers.

     In another, we switched array layout from column-major to row-major (CL mandated), or in the parlance of the time, "DCP stood the world on its ear."

     Those were delicate builds that took the "wobblies" (world-workers) a while to build.

     But both of those were just from 1 major release to the next. Trying to make the hop across multiple releases would have been almost a full cross-compiler.

     Most of the time it was the simpler case, though.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Friday, 28-Nov-2025 01:31:32 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor It is surprisingly hard to write a cross compiler on the Lisp Machine, FWIW.

     The only one I know about was for Falcon (LMI/Gigamos) thing .. And I mean like a true(-ish) cross compiler.

     @cstross

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Friday, 28-Nov-2025 03:46:59 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor Won't argue, but I do not recall anything cross-compiler like in Genera. It was the same two pass compiler ...

     As for 3600, and CADR -- the 3600 ran CADR QFASLs in the beginning. In fact, the two ran the same microcode in the very very early days.

     While 3600 and CADR were different, the microcode was the same (just like between CADR and Lambda!).

     CLEO .. no clue.

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Friday, 28-Nov-2025 03:47:00 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     Symbolics had some *sorta* cross compilation to get across major releases with file format changes, array layout changes, etc. Not real cross-compilers.

     But the bigger deal was when there was an architecture switch: the LM-2/CADR machines had to make the first binaries for the 3600s (L-machines), and the 3600 series had to make the first binaries for the I machines.

     Those were completely different instruction sets, and basically ran the new architecture's rewritten compiler inside a compatibility package on the old architecture. And they (mostly) only had to work once, so the new architecture machines could bootstrap themselves thereafter. So again, not a robust cross-compiler.

     No idea how the CLEO stuff (basically PC application delivery) worked.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Friday, 28-Nov-2025 14:33:26 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor I have early microcode for 3600, the source format was essentially the same.

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Friday, 28-Nov-2025 14:33:27 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     The hacked-up compilers for compiling to a new architecture were never released.

     And the 3600 L-mach microcode was *very* different from the LM-2/CADRs, as were the binary file formats. I recall it very differently than you do.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 21:30:34 JST Alfred M. Szmidt

     in reply to

     • Christian Lynbech
     • Lars Brinkhoff
     • Weekend Editor

     @mapcar A cross compiler must be entirely decoupled from the running system, Lisp Machine compiler isn't.

     Compiling for a different language is "trivial" in the sense all you do is spit out Lisp and compile that macrocode.

     @larsbrinkhoff @weekend_editor @cstross

   • Embed this notice
     Christian Lynbech (mapcar@mastodon.sdf.org)'s status on Sunday, 30-Nov-2025 21:30:35 JST Christian Lynbech

     in reply to

     • Lars Brinkhoff
     • Alfred M. Szmidt
     • Weekend Editor

     @larsbrinkhoff @amszmidt @weekend_editor @cstross Not entirely sure what is meant by cross-compiling, but Symbolics had a number of compiler for different languages, certainly including FORTRAN but also C (I think).

   • Embed this notice
     Lars Brinkhoff (larsbrinkhoff@mastodon.sdf.org)'s status on Sunday, 30-Nov-2025 21:30:37 JST Lars Brinkhoff

     in reply to

     • Alfred M. Szmidt
     • Weekend Editor

     @amszmidt @weekend_editor @cstross Why is it hard?

     I found it hard to write a Forth cross compiler. My mental block was mostly that the same symbol may refer to three different things depending on context. In a way, boostrapping a language using itself can be more confusing than doing it from another language.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 21:37:10 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor The early L-machine system was around System 78, both used the same Macrocode instruction set for the most part, and the input for CADRLP-like assembler was similar enough that it was a bunch of #+/#- hacks.

     It was exactly the same situation with CADR and Lambda -- on the wire, they are entirelly different. But the same input was used (with a few #+ here and there and everywhere).

     Remember, this is when the LM-2 still was in use ....

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Sunday, 30-Nov-2025 21:37:11 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     They're written in a lisp-like notation, to be sure.

     But the L-machine is a much more parallel micromachine, with completely different microinstructions and macroinstructions.

     I can't for the life of me imagine them being the same in any meaningful sense.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 21:38:04 JST Alfred M. Szmidt

     in reply to

     • Lars Brinkhoff
     • Weekend Editor

     @larsbrinkhoff Because if you change a variable that is used by the whole system, you screw the running system.

     To make a proper cross compiler, you need to decouple _everything_ -- which is hard, since the QC is part of the system.

     @weekend_editor @cstross

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 21:45:08 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor I.e. around the time of the A-Machine

     .. If anyone remembers that.

     @cstross

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 23:11:49 JST Alfred M. Szmidt

     in reply to

     • Weekend Editor

     @weekend_editor It might have changed with the time...

     I only have access to some very very early stuff.

     @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Sunday, 30-Nov-2025 23:11:51 JST Weekend Editor

     in reply to

     • Alfred M. Szmidt

     @amszmidt @cstross

     Ok, we remember differently: the L-machine macrocode (and microcode) were quite different in my memory.

   • Embed this notice
     Alfred M. Szmidt (amszmidt@mastodon.social)'s status on Sunday, 30-Nov-2025 23:17:07 JST Alfred M. Szmidt

     in reply to

     • Lars Brinkhoff
     • Weekend Editor

     @weekend_editor

     Don't remember how Symbolics did it, but Zeta-C and CT-ADA on Lisp Machine essentially dropped Lisp to then pass to QC.

     @larsbrinkhoff @cstross

   • Embed this notice
     Weekend Editor (weekend_editor@mathstodon.xyz)'s status on Sunday, 30-Nov-2025 23:17:08 JST Weekend Editor

     in reply to

     • Christian Lynbech
     • Lars Brinkhoff
     • Alfred M. Szmidt

     @amszmidt @mapcar @larsbrinkhoff @cstross

     The Symbolics Fortran/etc compilers didn't first compile to lisp.

     They looked at the L machine architecture - a stack machine with 256 registers to buffer the top of stack - as though it were a register machine.