anthk

The Computational Beauty of Nature it's similar and it has the code of the book there:

https://github.com/gwf/CBofN

Some tools might crash X under CWM for OpenBSD, switch to FVWM or use some tool like mimalloc.

On Lisp, the book basically builds integers based on conses, kinda like Peano Axioms.

CL is the big cousin of Elisp, almost.

GIving the device tree it looks far worse.

TBH with the DDD debugger you had a graph with the C structures right away.

On IntelME/AMD PSP:

https://jxself.org/titanic.shtml

He did it well. On "security", the author loves more to own his code/adata than anything. as did the PDP10/ITS hackers.

Also on Free Pascal/Lazarus:

https://peazip.github.io/

I didn't know PeaZip was written in FP.

Lazarus still exists; but SBCL badly needs an CLIM (MCCLIM better) based GUI REPL for the good (Listener and such, a la Smalltalk). Everyone can just use Emacs/Lem and then for GUI needs, the Listener/Debugger/Viewer interface.

Sorry, I hit the nested comment limit. On MIT Scheme, it used to recommend some older version, specially the first edition, but on Chicken 5 with the SICP related SRFI's loaded and maybe scm-sicp you can hit an almost 100% compatibility.

On differences, I already said that there's local library overlapping from the own subdialect implementations, such as Chicken Eggs and Guile ice-9 modules, but if you start them with R5RS or RSR7 standard compatibility flags the differences fade away, altough there are rough edges:

https://doc.guix.gnu.org/guile/latest/en/html_node/R6RS-Inco...

It's like ANSI C vs C99 but worse.

So I use Scheme for small scripts with S9 (R4RS standard) plus Unix and NCurses related addons.

For learning SICP, I use Chicken 5 with 203 and 216 eggs plus the ~/.csirc and call it done. Most of the R5RS stuff from SICP will run fine under S9 too with tons of patience (and you can maybe adapt the postscript generating Scheme code from the "Computer Abstraction" books for the frame language and just spit out some PS file). It's just basic geometry with vectors in the end, something SICP will teach you throughly. If you finish SICP with Chicken you for sure will be able to even adapt the threading Scheme code from the chapters for an R4RS compliant Scheme like S9 as it already has some Unix/thereading support. Just generate some wrapping functions and call it done :). It's, for sure a great exercise for Lisp and CS, and far easier to do, for example, than making a ANSI C compiler being C99 compatible. Or, as a modern example, backporting modern Rust/Java functions to older compilers.

On S9 Scheme (s9fes) you could just hack away most of the exercises at blinding speed...

I prefer Common LIsp for bigger tasks (altough you can learn a lot of CS with Gentle Introduction to Symbolic Computation and Paradigms of Artificial Intelligence Programming too), but SICP it's 'harder' and it will put you on God low-level mode making the CL exercises at light speeds despite the design differences between Scheme and CL:

Common Lisp:

  (defun hello () (princ "hello"))
   (hello)

Scheme:

   (define (hello) (display "hello")) 
   (hello)

The reason on picking CL over Scheme: If the code runs under SBCL, CCL and ECL call it done, it will almost run on every Common Lisp compiler/interpreter, even the commercial ones. Quicklisp (and UltraLisp) will handle the dependencies itself and CLHS (Common Lisp Hyper Spec) will have everything doccumented on your hands. The editor? Emacs+Slime or Lem, with both have functions to look up functions and autocomplete, with help about a function or library in the spot. Far better than Scheme in the end for big projects.

Both will teach you iteration vs recursion, anonymous functions (lambdas), closures and so on.

Github has several repos, there's one which works for Guile (and Racket for the 2nd lesson), but you can just use Chicken Scheme 5 for all of them.

Here are the commands to build the addons needed for Chicken Scheme 5 and SICP compat. You need gcc, make and similar tools on your Unix machine. Install "build-essential" on Ubuntu, Debian and derivatives will just work.

     chicken-install -s srfi 203
     chicken-install -s srfi 216
     chicken-install -s trace

Then at ~/.csirc

     (define
        (displaynl x)
        (display x)
        (newline))

     (define pi (* 4 (atan 1.0)))

    (import scheme)
    (import (srfi 203))
    (import (srfi 216))

Displaynl and "pi" are just for convenience.

Simlar language, compatible with MSDOS, CP/M and Unix:

https://t3x.org/t3x/0/index.html

I was there, a 3 minutes walk from home in Northern Spain. It wasn't as charming as I expected, but the environment with cheerful people looked fine.

Indeed. Scheme it's amazing for embedded (such as s9) and its small size. Also, the SICP it's cool to do with Chicken Scheme and this ~/.csirc (and chicken install srfi-203 and srfi-216):

    (import scheme)
    (import (srfi 203))
    (import (srfi 216))
 
 (define (displaynl x)
  (display x)
  (newline))
 
 (define pi (* 4 (atan 1.0)))
 

Even if Chicken has Hypergiant to play with 3D objects, Common Lisp has Kandria, Sketch, Kons-9...

From Scheme, after finishing SICP as an Scheme exercise (and CS course), just jump into Common Lisp, and finish both Gentle Introduction to Symbolic Computation and Paradigms of Artificial Intelligence, where you will implement a micro-Scheme in Common Lisp itself as an exercise.

SBCL allows you to create working stuff with very few dependencies (uiop and the like from QuickLisp/Ultralisp). With Scheme/Chicken you will get lost in a maze of eggs and SRFI's.

And, on CS/academics, if you finish SICP both GITC and PAIP on on Common Lisp will be a breeze and it will give you superpowers with these three books.

Well, SBCL can just use sources just fine. On Guile not being fast enough, it got a JIT since version 3 and it can be pretty fast. It must be, you know, because if not Guix would be even slower.

For that I use Chicken 5 with trace, srfi-203 and srfi-216.

Uhm. I'm divided. Common Lisp it's the weird cousin, bloated at first but in the end you get SBCL, ECL or CCL and almost everything will work the same. With Scheme, you need to instal SRFI's to complete SICP exercises and then there's R5RS and R7RS.

You have no way to run Hypergiant under Guile. In Common Lisp, tons of packages for QuickLisp/UltraLisp will run on SBCL, CCL and ECL with ease.

In the end Scheme+Dependencies can be more convoluted than a subset of Common Lisp (you can avoid CLOS if you don't need it for instance).

LibreOffice will do it better.

In the 2000's 256MB were the bare minimum, my PC in 2002-3 had that.

With an OS the PC requeriments for that game under Windwos XP would have been like 256MB/384MB.

Integers. You could almost emulate a PSX in a potato (Pentium MMX) with -ffast-math -O3 except for Alpha channel (transparencies) in textures.

>Yet, somewhere the spirit persists. Hidden away in encrypted Matrix rooms, deep inside dead drop Git repositories and onion forums, the real work continues. The underground never died — it just moved to quieter places.

You wish. True hackers wrote HAKMEM https://en.wikipedia.org/wiki/HAKMEM, wrote ZMachine interpreters in PostScript, wrote compilers for the Subleq machine with memory indirection and ran GNU/Linux on it. You pale against Lisp hackers who almost ate Discrete Math books for breakfast.

The PC "hacking" was nothing more than a bunch of kids playing with really underopowered toys.

There's more hacking spirit in Fabrice Bellard and Common Lisp/Scheme books than the whole PC hacking/cracking and phreakign scene.

This is a genuine hacking act:

https://bellard.org/dvbt/

This too:

http://www.erikyyy.de/tempest/

The same with Emacs hackers repurposing the editor for anything. IRC, Email, ZMachine interpreter, music and video player interfaces, web browsers, equation solvers, controlling aiports in Germany as an ATC messaging router (and I am NOT kidding about the last one)...

This might be the craziest achievement from a GNU product ever. Repurpossing a text editor to manage a civil infraestructure:

https://www.emacswiki.org/emacs/EmacsStories

Every language has his own name for tons of places. In Spanish it's Zaragoza and in English "Saragossa". Ditto with Londres/London.

Basque Spaniard there; I will be at one of the easiest places to watch it (mountainous place, near the Bay of Biscay).

Vector icons. It can be fit under 50MBs.

Winemaker + winegcc.

Vulkan existed before with AMD's Mantle or whatever was called.

Por a ZMachine interpreter; there are ones for CP/M and DOS (Frotz).

The XOR window frame was on most X11 window managers since late 80's and early 90's.

>The SDK requires "sed" (https://en.wikipedia.org/wiki/Sed) and "perl" (https://en.wikipedia.org/wiki/Perl) to be installed.

Perl can do sed(1).

Once you control the hosts CPU it's game over for the guest. The best you can do is to fetch old PPC G4 Apple computers or Thinkpads.

As a good example of what Common LIsp can do in real life:

https://en.wikipedia.org/wiki/ACL2

On more mundane software, both Maxima and FriCAS are good examples (Math CAS).

On games/engines, there's Kandria.