kitns & tamsyn & tails, oh my! @kitsune@toot.cat

@68km you're right, i did. for the purposes, please assume it's under ^X / ^C / ^V

please boost, btw!

@ed1conf ;-) not for these purposes! it inherits the keystroke set of whatever is driving stdin (same goes for ex, teco, edlin, etc)

which text editor keystroke set do you Just Know?

@psf that's the problem with x86 - the set of 1-byte instructions is really limited; but most of them are abbreviations for 2-byte instructions, and the ones that aren't can usually be paired up with something else to be useful. but almost every 8086 instruction has a 2-byte encoding. the only real problem you run into is bytewide ALU operations with constants; you can ignore the sign-extending constants and the single-byte offsets from index registers, but the only way to maintain the word length is either to use prefixes or to insist that only AL can do ALU ops with constants (instead of other registers).

for NEXT, treating $97ad as a pseudo-16-bit instruction gives

    dw $97ad  ; lodsw
              ; xchg ax,di
    jmp [di]

which is compact enough to code inline, and doesn't cause a BIU stall on the 8088

an idle thought: what subset of the ia32 instruction set is dword-aligned? and is any part of the amd64 instruction set qword aligned?

(compound instructions count - for instance

    inc eax
    inc eax
    inc eax
    inc eax

would qualify)

asking for a Forth compiler friend ;-)

@bd strictly speaking, anything that stitches a chunk of code to one or more chunks of data is a closure. so that's classes, prototypes, Scheme-style implicit closures, ZetaLisp-style explicit closures, even Forth's CREATE ... DOES>

the new thing Scheme does is make closure creation implicit. (lambda ...) moves from being just a way to wrap up a list as a function value, and becomes a macro in its own right; the variables to be stored in the data associated with the code in the lambda are extracted from the (lexical) calling environment, automatically. or not extracted at all; a number of scheme implementations simply preserve the entire environment at that point, whereas others (eg Chez Scheme) have the compiler figure out which variables are preserved and automatically flatten closures to only preserve those.

as for omitting it - well, it's easy enough to synthesise, eg. in C:

   struct thing {
      struct thing *do(
           struct thing *this,
           char *how );
      ...
   } *me;

   me = new_thing( ... );
   ....
   return me->do( me, "like this" );

but something useful enough that people keep reinventing it gets painful to express like that, over and over... which is part of how C++ came about (originally it was just "C With Classes", in both name and function)

so i'd say omitting closures altogether is a false economy. whether the Scheme approach justifies its complexity, though, is a whole other matter, especially in the absence of heap-allocated function call frames and/or garbage collection; something more explicit might be a better idea

@akkartik @vertigo

re LB: image is a tweet from @LevisBecker, replying to @AgentNdn, and reads

"Libertarianism is Thoreau building a cabin and living all self reliant while his mom and sister bring him food and do his laundry."

also, the authors of Ribbit (mentioned yesterday) have added another Lisp OS to the pantheon: Mimosa

https://github.com/udem-dlteam/mimosa

basically, just enough kernel support to boot Gambit

re LB: the first image is a US Uncut headline reading "A toddler has shot a person every week in the US for two years straight"¹ and the second is a CNN headline: "New US dietary guidelines include babies and toddlers for the first time"

¹ you'd think someone would have taken that toddler's gun away from him by now... maybe that's why the casualties, they keep trying?