IRC channel logs


back to list of 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]>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]>then if I just put cursor over the "internal symbols" line and press return
<lispmacs[work]>and so on, as deep as I want, until getting to disassembled output
<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>CL is a descendant of the original Lisp, which predates ASCII, so everything tends to be capitalized.
<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 ?
<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?
<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