IRC channel logs

<ieure>Z80 got used up through the 90s as a sound coprocessor for a lot of hardware. I think it's still used for embedded stuff. Like a lot of 8-bit CPUs, they're still in production and you can buy them brand new. Which sure is handy for me.

<ieure>The Dig Dug/Xevious/Galaga hardware really likes to eat Z80s for some reason.

<ericcodes>My first experience with a z80 was my TI-84

<dsmith>I had the z80 card for the C64. CP/M on that silly drive was a nightmare

<ieure>Ha. I ran it briefly on my C128DCR. Pretty nice machine, but all I ever did was boot it in C64 compatibility mode to play games.

<ieure>Used to have an Epson machine, I forget the model, but it was a Z80 CP/M box.

<ericcodes>oh I guess my dad's Kaypro II was my first z80 experience, but I didn't know it at the time

<ieure>My dad's Timex-Sinclair 1000 was the first computer I ever touched (I was really young), that's a Z80 machine, too.

<dsmith>Yeah, brother-in-law had a Sinclair (wasn't by brother-in-law then)

<lispmacs[work]>hi, does guile have something like SLIME-INSPECT, for inspecting objects in Emacs?

<lispmacs[work]>does geiser have an inspector?

<civodul>lispmacs[work]: hi! Guile’s REPL has a simple inspector

<lispmacs[work]>oh, okay, I see it here

<lispmacs[work]>,help inspect

<lispmacs[work]>can I return a module as an object?

<lispmacs[work]>I'll look in the manual...

<lispmacs[work]>current-module

<lispmacs[work]>it seems like there is a lot of introspection procedures in guile but not really a simple to use inspector like with SLIME

<lispmacs[work]>the built in inspector can't really tell you anything about a module object, e.g.

<lispmacs[work]>you have to find the various module inspection procedures if you want to learn anything

<lispmacs[work]>or, I suppose maybe just more display and pretty-print methods need to be added for module objects?

<lispmacs[work]>kind of spoiled with SLIME in CL where you can see every detail of every object imaginable and then quickly inspect all the objects behind all those details

<lispmacs[work]>I'm not see how to really inspect a module object with just the built-in inspector. If I do ,i (current-module) that gives me #<module (guile) 7…> inspect> and the print, write, and display functions don't give any more information

<graywolf>I don't know anything about SLIME, so I'll ask: what information would you like to see?

<lispmacs[work]>e.g., if I run slime-inspect on a package object, I get this output:

<lispmacs[work]> https://bpa.st/7PWA

<lispmacs[work]>then if I just put cursor over the "internal symbols" line and press return

<lispmacs[work]> https://bpa.st/HRNQ

<lispmacs[work]>and so on, as deep as I want, until getting to disassembled output

<lispmacs[work]>e.g.,

<lispmacs[work]> https://bpa.st/J5AQ

<graywolf>Hm, I feel like you will be able to get (most?) of the info there, but I am not aware of anything built-in.

<graywolf>It looks pretty cool

<ieure>The SLIME inspector is really, really nice.

<graywolf>I (think) guile is able to provide the raw data, but I do not know if anyone built an interface over it.

<dthompson>seems like every few months a CLer comes in here and asks a question about a slime specific feature and then says how great slime is

<dthompson>geiser is the closest thing to slime that we have around here

<dthompson>you can disassemble a procedure with ,x or ,disassemble

<lispmacs[work]>those annoying CLers ;)

<lispmacs[work]>I have been mostly coding in CL lately. But haven't been trying to get more "intimate" with the guix repl

<lispmacs[work]>but have been, I meant

<ieure>Yeah... it's because SLIME is really great. :)

<ieure>My only beef is that it doesn't have a debugger as good as edebug or CIDER.

<dthompson>I don't do CL so whenever I see some slime output I don't really understand what's going on. don't know what ideas to even steal

<ieure>haha

<dthompson>EVERYTHING JUST LOOKS REALLY LOUD

<ieure>CL is a descendant of the original Lisp, which predates ASCII, so everything tends to be capitalized.

<dthompson>yeah

<dthompson>it old

<ieure>Yeah, it's a truly wild combination of stuff more advanced than any other language still has, and pretty primitive.

<dthompson>alien technology etc etc

<ericcodes>I really tried to like CL because of Greenspun's tenth rule, but the crustiness and foot guns just got to be too much.

<ieure>I greatly enjoy mastering arcane footguns, so I think CL is terrific.

<dthompson>cl is both really cool and something I don't want to touch at all

<graywolf>btw is anything happing with https://www.emacswiki.org/emacs/GuileEmacs ?

<ieure>I'd honestly love to have a full-time job hacking CL.

<dthompson>graywolf: no

<ieure>But I settle for Clojure.

<dthompson>scheme suits me very well. would just like to snarf some of the goodies from cl

<ieure>I still don't have my head around Scheme's macro system.

<dthompson>syntax-rules is pretty easy, syntax-case is difficult but that's where the good stuff is

<lispmacs[work]>how do I see what source code is assocated with an object?

<pinoaffe>lispmacs[work]: I don't think that is possible in guile

<pinoaffe>but I may be wrong

<lispmacs[work]>erm, well, the debugger knows somehow

<lispmacs[work]>I see there is source-properties, but that doesn't seem to work

<lispmacs[work]>I think that got replaced by the read-syntax think but I don't understand what procedure is used to get the source location from the created object

<pinoaffe>ah, do you just want the source locations?

<lispmacs[work]>yeah

<pinoaffe>in that case, you can use the function `source-properties'

<lispmacs[work]>I tried source-properties on some guile procedures but am getting empty list back

<lispmacs[work]>or, some guix procedures, I should say

<lispmacs[work]>I'll try some guile ones

<pinoaffe>ah yes, I stand corrected: source-properties aren't used anymore, so running `source-properties` on guile objects won't return anything (unless you or someone else annotated them)

<lispmacs[work]>same also for ones in the guile module

<lispmacs[work]>what's the replacement for source-properties?

<lispmacs[work]>I figured out how to get a list of all symbols in a module. If I can figure out how to point to the source for any symbol, I'll have the keys to the kingdom

<lispmacs[work]>WHA HA HA

IRC channel logs

2024-01-18.log