<Spawns_Carpeting>
what is the type of the buffer returned by socket-receive?
<Spawns_Carpeting>
i can use ssltunnel for SSL/TLS connections I support
<Spawns_Carpeting>
suppose
<opalvaults[m]>
*no-defun-allowed* I love that guys writing. I believe he wrote a paper about a common lisp operating system that I really liked.
<opalvaults[m]>
hard to find through the website, thankfully i bookmarked it. For anyone interested: http://metamodular.com/closos.pdf
dra_ has joined #commonlisp
dra has quit [Ping timeout: 240 seconds]
dra_ has quit [Remote host closed the connection]
Inline__ has joined #commonlisp
<rotateq>
and dre, good to have you on board btw :)
<dre>
thanks :D
Inline has quit [Remote host closed the connection]
<rotateq>
we need every potential magician for the future :)
pve has quit [Quit: leaving]
jstoddard has joined #commonlisp
<Spawns_Carpeting>
how can I turn the buffer returned by socket-recv into a string?
<Spawns_Carpeting>
I am not exactly sure what the type is in the first place, whether its a vector or hwat
<Spawns_Carpeting>
i could setup a local irc server for testing but it would be easier to uh, just know the type
<Spawns_Carpeting>
its sb-bsd-sockets:socket-receive
<Xach>
Spawns_Carpeting: it's been a while, but i believe it's a vector of octets. octets-to-string will convert it if you like.
<Spawns_Carpeting>
thanks Xach
<Spawns_Carpeting>
very cool!
<Xach>
Spawns_Carpeting: you can use TYPE-OF to find the type of an object.
rgherdt has joined #commonlisp
<Spawns_Carpeting>
oh geez i didn't know that
aartaka has quit [Ping timeout: 256 seconds]
<Spawns_Carpeting>
how can I use sb-bsd-sockets inside of an asdf package? Do I need to :use something, or just require it?
<Spawns_Carpeting>
or if there is some good reading material
amb007 has quit [Ping timeout: 240 seconds]
x88x88x has quit [Ping timeout: 240 seconds]
<Spawns_Carpeting>
I am trying to logically work my way through this so I know how to do it in the future. I see that sb-bsd-sockets is itself an asdf "system", but I am not sure if the :use part of a defpackage imports systems, packages, or what exactly
<Xach>
Spawns_Carpeting: defpackage manages the availability of symbols
<Xach>
Spawns_Carpeting: asdf manages loading systems and their prerequisites
<Xach>
Spawns_Carpeting: so, if you have a project with an .asd system file, :depends-on (#:sb-bsd-sockets) is a thing you could have in your file.
<Xach>
to refer to external symbols in the sb-bsd-sockets package without a prefix, you could :use #:sb-bsd-sockets in your defpackage form.
<Xach>
lots of options and no one best way! that can make it slow to get started.
<Xach>
reading other code can help though.
<Spawns_Carpeting>
so the (defpackage (:use)) uses other packages?
x88x88x has joined #commonlisp
<Xach>
Spawns_Carpeting: it makes it so you can refer to their external symbols without a package prefix
<Xach>
so after (defpackage #:foo (:use #:cl)) (in-package #:foo), you can refer to CL:CAR without the "CL:" part
<Xach>
or CL:DEFUN, etc.
frodef has quit [Ping timeout: 256 seconds]
<Xach>
If you don't :use, you can still refer to them just fine - but you have to write the prefix.
<Spawns_Carpeting>
okay that makes sense
frodef has joined #commonlisp
<Spawns_Carpeting>
thank you Xach
<Xach>
there are a few ways to manage that sort of thing. importing is one, and shadowing comes into play when you :use multiple packages when there's a conflict
<Spawns_Carpeting>
what does the pound symbol do in the defpackage/defsystem form do?
<Spawns_Carpeting>
seems to work with and without it
<hayley>
#:foo reads as an uninterned symbol with the name FOO.
<hayley>
:foo reads as a symbol interned into the KEYWORD package, i.e. a keyword.
rgherdt has quit [Ping timeout: 260 seconds]
<Xach>
Spawns_Carpeting: it's a way to use a symbol for its name without interning it in any package
<Xach>
the real critical part is the name of the symbol - the #:... is syntax for a particular kind of symbol.
VincentVega has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
frodef has quit [Ping timeout: 268 seconds]
frodef has joined #commonlisp
x88x88x has quit [Read error: Connection reset by peer]
<rotateq>
yes hayley already had and read it ;) but have to rework
mingus has joined #commonlisp
<rotateq>
was fascinating what it gives
Colleen has quit [Read error: Connection reset by peer]
Colleen has joined #commonlisp
ilmu has quit [Ping timeout: 240 seconds]
tyson2 has joined #commonlisp
Oladon has quit [Quit: Leaving.]
mingus has quit [Ping timeout: 240 seconds]
ilmu has joined #commonlisp
waleee has quit [Ping timeout: 256 seconds]
<Spawns_Carpeting>
is there a list util library for cl similar to elisp's dash.el?
<Spawns_Carpeting>
dash defines a bunch of handy functions for working with lists, like flatten, filter, map, take, take-last, take-while, etc etc etc
<Spawns_Carpeting>
i realize many are actually built into lisp already, but some aren't
<Xach>
Spawns_Carpeting: alexandria has a lot of stuff
<Xach>
Spawns_Carpeting: not just for lists
s-liao has quit [Ping timeout: 256 seconds]
green__ has joined #commonlisp
<rotateq>
Spawns_Carpeting: and it can also curry your meals :) or you do the alias "to schoenfinkel"
atgreen has quit [Ping timeout: 260 seconds]
Everything has quit [Quit: leaving]
winning-luser has quit [Quit: Leaving]
atgreen has joined #commonlisp
green__ has quit [Ping timeout: 240 seconds]
<jstoddard>
Hi everyone, say I have a class with three slots that have accessors a, b, and c. I want to create a subclass--all the methods on the original class make sense for my subclass, but it would make more sense to users if the accessors were named x, y, and z.
<jstoddard>
Is there a straightforward way to "alias" the names of those accessors for my subclass?
<rotateq>
just cause I see it now, it's a convention to place earmuffs around global parameters :) so one can say from reading "ahh that's a global parameter". and also wrapping constants with plus signs
<Spawns_Carpeting>
hayley: The function IRC::STRING-TO-OCTETS is undefined.
<hayley>
And I wrote babel:string-to-octets after, with the babel: package prefix. Granted, IRC and programming is asynchronous. But you probably also want babel:octets-to-string instead of octets-to-string, to avoid the same error when you receive a message.
<Spawns_Carpeting>
is babel a built in package or something?
<rotateq>
you can load it with quicklisp i guess
<Spawns_Carpeting>
there is a built in function that does it though
<Spawns_Carpeting>
but for some reason it only works in the repl, not in this snippet
<Spawns_Carpeting>
i suppose it probably just loops through the string an creates a vector of char codes
<rotateq>
yes when you load a new image and babel isn't loaded into it won't know the symbol
<Spawns_Carpeting>
I don't have babel installed afaik
<Spawns_Carpeting>
unless its shipped with sbcl
<Spawns_Carpeting>
in which case I guess i just need to add it to depends or something
<rotateq>
for this kind of thing we have quicklisp :)
<Spawns_Carpeting>
i don't have quicklisp installed either
<rotateq>
yes in an asd file you define for your system
<rotateq>
oh go ahead, you will enjoy the xach-technology
<rotateq>
with it you load/build systems that define packages, which are container for symbols
s-liao has quit [Quit: Ping timeout (120 seconds)]
<jstoddard>
Things work! You all just saved me potentially hours of tinkering around to figure out these little details about accessors, that I can now spend learning about what I'm trying to do (raytracing, if anyone cares). So thanks!
<rotateq>
nice
<rotateq>
I didn't help anything, but pleasure. :)
<rotateq>
yes I care jstoddard
<rotateq>
improving the raytracer from Alexander Lehmann also with parallel and concurrent calculation or such could be a good go-on project and for rendering more complex scenes
<jstoddard>
Oh, he has videos up about raytracing in Common Lisp. Here I am working through a C++ tutorial rewriting things in Lisp.
<rotateq>
yes, I think you will learn more from it
<rotateq>
just cause C++ things aren't so directly adaptable (in my head)
<rotateq>
do you have this tutorial, so a link to?
<rotateq>
Much comes together that's used in game engines. :)
<rotateq>
ah nice thx
<jstoddard>
Yeah, I never really got into C++, so it's kind of like speaking Spanish but trying to read Portuguese.
<rotateq>
One of the first big differences between C++ OO-system and CLOS is the decoupled classes and methods that are specializations to generic-functions with also possible method-combinations.
<rotateq>
And of course the multiple-dispatch.
<rotateq>
But maybe let's take it to #clschool.
<rotateq>
jstoddard: When in Rome, do as the Romans do. :)
<rotateq>
and always write "#define public private" in C++ headers
<rotateq>
replace the above part with "... are specializations to a generic function ..."
<jcowan>
When in Rome, shoot off Roman candles.
<Spawns_Carpeting>
how exactly do vectors work in lisp? I can't seem to get vector-push to work
<Spawns_Carpeting>
i have defvar x (vector)
<Spawns_Carpeting>
then I want to do (vector-push 1 x)
<rotateq>
jcowan: heh. :D
<Spawns_Carpeting>
it throws an error saying its the wrong type
<hayley>
Only if the vector is adjustable; your average vector is not.
<rotateq>
Spawns_Carpeting: on what kind of vector?
<rotateq>
or vector-push if it has a fill-pointer that is at the moment smaller than (1- length)
<hayley>
Er, the vector needs to have a fill-pointer, but it doesn't have to be adjustable for VECTOR-PUSH...
<hayley>
but I would recommend using an adjustable vector and VECTOR-PUSH-EXTEND, unless you know you definitely don't want resizing semantics.
<Spawns_Carpeting>
i didn't realize vectors weren't dynamically sized by default
<Spawns_Carpeting>
whoop!
<rotateq>
oh noez of course "smaller than the length"
<rotateq>
Spawns_Carpeting: there are simple vectors firstly, which you type with #(1 2 3)
<hayley>
A Common Lisp vector is just a one-dimensional array, whereas some languages use "vector" to mean a resizable one-dimensional array.
<Spawns_Carpeting>
yeah I am used to c++ and stuff where vector = a dynamic array
<rotateq>
and how about strings in C++? like in C?
<rotateq>
we could give them zero-dimensional arrays too
<Spawns_Carpeting>
strings in c++ are pretty much just an std::vector but specialized afaik
<rotateq>
ah okay. in CL they are also vectors specialized to element-type character and thous you can look up their length directly
Bike has joined #commonlisp
<Spawns_Carpeting>
darn i am getting errors trying to decode the bytes from the socket into UTF8
<Spawns_Carpeting>
i ended up using "flexi-streams::octets-to-string"
<Spawns_Carpeting>
it looks like it supports UTF-8
frodef has quit [Ping timeout: 260 seconds]
frodef has joined #commonlisp
taiju has quit [Ping timeout: 268 seconds]
<hayley>
WHAT ERRORS?
<hayley>
I think something is going wrong if babel:octets-to-string doesn't work, but no one would know what, if you only say you are "getting errors".
<Spawns_Carpeting>
it complains that #\E is not an octet
<Spawns_Carpeting>
turns out socket-recieve returns a string rather than byte vector
<Spawns_Carpeting>
very strange api choice
<hayley>
Well, guess you don't need to convert the string then?
<Spawns_Carpeting>
nope, I didn't realize that but I am not going to complain
<rotateq>
hayley: as long as they're signaled and not thrown
<rotateq>
of course it's not an octet, it's a character
taiju has joined #commonlisp
<Spawns_Carpeting>
well, I figured the function would return bytes, not a string
igemnace has quit [Remote host closed the connection]
<beach>
Good morning everyone!
<Spawns_Carpeting>
do I use setf of setq to set slots that have been brought "into scope" with with-slots?
<Spawns_Carpeting>
neither seem to be working for me
<Spawns_Carpeting>
like (with-slots (x y z) c (setf x 1))
<Spawns_Carpeting>
the problem was, I had the loop setup to read from socket until the message delimiter appears at least once in the connection buffer, but it was looping forever
<Spawns_Carpeting>
i fixed it though, i forgot to concatenate the buffer with the data from the socket
<Spawns_Carpeting>
thanks for help tonight guys
s-liao has joined #commonlisp
semz has quit [Ping timeout: 260 seconds]
semz has joined #commonlisp
<Spawns_Carpeting>
what would something like (setf (struct-field struct) nil) do in terms of bytecode?
<Spawns_Carpeting>
a better question might be what exactly is going on when using the slot accessor functions
<Spawns_Carpeting>
does that eval to some special symbol or something
<beach>
Bytecode? It could be native code or interpreted.
<beach>
There would likely be native instructions to compute the address of the slot and then store a new value at that address.
<Spawns_Carpeting>
I am thinking of a high level bytecode type of thing. just curious because I am still working on my personal lisp project, but haven't got as far as structs and classes yet
<Spawns_Carpeting>
im still in the early stages of compiling it actually, progress has been slow
<Bike>
if you're asking what the lisp compiler compiles into, it's not necessarily bytecode. sbcl and ccl both compile to native code for example.
<Bike>
like, there is no bytecode to speak of, so your question does not make sense.
<Bike>
if there was bytecode it would be the same way you do a structure access in pretty much any kind of instruction set, though? memory set kind of deal
<Spawns_Carpeting>
i mean, what kind of bytecode would it look like on a bytecode based lisp interpreter
<Spawns_Carpeting>
ah okay that makes sense
dre has quit [Quit: Leaving]
<Spawns_Carpeting>
probably a specialized opcode to handle structs
<Spawns_Carpeting>
ill have to look at how python handles this
<Spawns_Carpeting>
ofc its not a lisp, but i am stealing many ideas from it
Guest74 has joined #commonlisp
<Bike>
doesn't have to be specialized. it's just an index into a structure and then a load from memory. or store to memory.
<beach>
Spawns_Carpeting: I recommend you read up on compiler techniques.
<Spawns_Carpeting>
i certainly have been!
<Spawns_Carpeting>
i've made a great deal of progress
<Spawns_Carpeting>
but its slow progress
<beach>
OK.
<Spawns_Carpeting>
i seem to catch on to the whole compiler thing a little more slowly than others
<beach>
It's tricky stuff.
<Spawns_Carpeting>
i guess in my VM a struct slot accessor could just put a reference to a struct field on the stack or something
<Spawns_Carpeting>
yeah it can be for sure! it's a lot of information to process as well
aartaka has joined #commonlisp
<hayley>
The easiest solution would be to pass the name of the slot to a SET-SLOT instruction, or something.
<hayley>
...and also some description of the structure that you want to write to, if you are checking types like an accessor function would.
<hayley>
Compiling "x.y = 2" in CPython does just that, except without the type check part.
miique has joined #commonlisp
jealousmonk has quit [Quit: sleep]
alfonsox has joined #commonlisp
<Spawns_Carpeting>
very cool hayley
<Spawns_Carpeting>
i have another question, sorry for asking so much stuff. are SBCL threads "managed", meaning I can use them without worrying about races and similar issues
<dbotton>
nope
<hayley>
Define "race".
<Spawns_Carpeting>
data races
<Spawns_Carpeting>
like, trying to read and write to something at the same time and ending up with the wrong value
<hayley>
As far as I know, Lisp implementations offer the same guarantees as Java, i.e. you'll read some written value and not total garbage.
<Spawns_Carpeting>
that's pretty good then
<dbotton>
race conditions, they just map to system threads which do not provide any protections
<hayley>
(It's basically free on modern hardware, since cache coherency protocols just don't let you see word tearing.)
<dbotton>
Is there a way to "skip" adding to the return list during a mapping function like mapcar?
<dbotton>
(I can just strip nils from the return list but curious)
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<lisp123>
dbotton: I can't imagine so
<lisp123>
I usually would just write a custom collecting function
<lisp123>
e.g. (let ((IRC-STUFF ())) (mapc (lambda (a) (when (____) (push a IRC-STUFF)....
<dbotton>
thanks
tyson2 has quit [Remote host closed the connection]
<beach>
dbotton: Use LOOP for stuff like that.
<beach>
dbotton: ... WHEN ... COLLECT...
<dbotton>
Thanks.
pranavats has left #commonlisp [Error from remote client]
<dbotton>
Is (remove nil (mapcar inefficient?
<beach>
You will first CONS a list with NILs in it and then another list without them.
<beach>
Whether that's acceptable depends on your application.
notzmv has joined #commonlisp
<beach>
dbotton: I recommend you do the thing that gives the most readable and maintainable code. Then you can measure whether your solution needs performance improvements and if so where.
<beach>
dbotton: Programmers are notorious for being wrong about what parts of the code take the most resources.
<dbotton>
Agreed. The remove nil version in this case more elegant and efficient enough for its purpose
<beach>
This is especially true for inexperienced programmers, who often fail to design good algorithms and data structures, and instead concentrate on what they (think they) know, i.e. low-level performance.
<dbotton>
I tend to never optimize first round and try for readability first
<beach>
Sounds good.
<dbotton>
The the code is maintainable is infinitely more important to me
pranavats has joined #commonlisp
<dbotton>
I have code from 30 years ago that I still value because I can read what I did and
<dbotton>
not have to spend time figuring out what was done to optimize
s-liao has quit [Quit: Client closed]
Guest74 has quit [Quit: Ping timeout (120 seconds)]
<dbotton>
Most time modern compilers do a better job anyways
gaqwas has joined #commonlisp
ilmu has quit [Ping timeout: 268 seconds]
s-liao has joined #commonlisp
<Bike>
dbotton: you can do mapcan, returning a list of one element or nil. loop will probably be more readable though.
<dbotton>
thanks, will look in my am. gn
Bike has quit [Quit: Connection closed]
jstoddard has quit [Quit: goodnight]
frodef has quit [Ping timeout: 240 seconds]
gaqwas has quit [Remote host closed the connection]
Guest74 has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
treflip has joined #commonlisp
alvaro121 has quit [Ping timeout: 250 seconds]
alvaro121 has joined #commonlisp
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
Algernon69 has quit [Ping timeout: 268 seconds]
shka has joined #commonlisp
ilmu has joined #commonlisp
igemnace has joined #commonlisp
lisp123 has quit [Quit: Leaving...]
rgherdt has joined #commonlisp
rain3 has joined #commonlisp
happy-dude has quit [Quit: You have been kicked for being idle]
rain3_ has joined #commonlisp
Alfr has quit [Killed (zirconium.libera.chat (Nickname regained by services))]
Alfr has joined #commonlisp
rain3_ has quit [Client Quit]
luna-is-here has quit [Read error: Connection reset by peer]
luna-is-here has joined #commonlisp
luna-is-here has quit [Read error: Connection reset by peer]
luna-is-here has joined #commonlisp
karlosz has joined #commonlisp
Lycurgus has joined #commonlisp
gaqwas has joined #commonlisp
mingus has joined #commonlisp
mingus has quit [Ping timeout: 256 seconds]
treflip has quit [Remote host closed the connection]
treflip has joined #commonlisp
treflip has quit [Remote host closed the connection]
treflip has joined #commonlisp
cosimone has joined #commonlisp
mingus has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
loskutak has joined #commonlisp
karlosz has quit [Quit: karlosz]
gaqwas has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
nature has joined #commonlisp
mingus has quit [Ping timeout: 240 seconds]
Lycurgus has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
mingus has joined #commonlisp
mingus has quit [Ping timeout: 240 seconds]
nij- has joined #commonlisp
mingus has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
mingus has quit [Ping timeout: 260 seconds]
Algernon91 has joined #commonlisp
Algernon91 has quit [Read error: Connection reset by peer]
s-liao has quit [Quit: Client closed]
random-nick has joined #commonlisp
igemnace has quit [Remote host closed the connection]
s-liao has joined #commonlisp
<nij->
Anyone had fun with coalton?
gaqwas has joined #commonlisp
attila_lendvai has joined #commonlisp
<phoe>
there's a coalton-centric Discord server where you should be find some devs and users
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
waleee has joined #commonlisp
cage has joined #commonlisp
Inline__ is now known as Inline
Algernon91 has joined #commonlisp
Algernon666 has joined #commonlisp
Algernon91 has quit [Ping timeout: 240 seconds]
tyson2 has joined #commonlisp
Inline has quit [Quit: Leaving]
epolanski has joined #commonlisp
Inline has joined #commonlisp
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
<rotateq>
dbotton: oh, long in business :)
nij- has left #commonlisp [#commonlisp]
skyl4rk is now known as tlvb
Algernon666 has quit [Ping timeout: 252 seconds]
tlvb is now known as skyl4rk
Algernon666 has joined #commonlisp
<dbotton>
My first paid for program was 40 years ago. A program for the psych department of Nova university (south Florida us) running on trs-80s attached to a cables so could load the app to many machines from the same tape recorder
<dbotton>
Written in basic and hand translated assembly poked in to memory
Algernon91 has joined #commonlisp
Algernon666 has quit [Read error: Connection reset by peer]
Bike has joined #commonlisp
loskutak has quit [Ping timeout: 240 seconds]
<pjb>
dbotton: nice. Mine was a program in basic on TO7 to drive some lights on an advertizing panel for some conserve can manufacturer.
Algernon91 has quit [Ping timeout: 252 seconds]
s-liao has quit [Quit: Client closed]
Algernon91 has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 250 seconds]
waleee has joined #commonlisp
random-nick has quit [Ping timeout: 256 seconds]
gaqwas has quit [Remote host closed the connection]
Guest74 has quit [Quit: Connection closed]
Everything has joined #commonlisp
cage has quit [Ping timeout: 240 seconds]
cosimone has quit [Remote host closed the connection]
Inline has quit [Quit: Leaving]
cosimone has joined #commonlisp
cage has joined #commonlisp
cosimone has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
ilmu1 has joined #commonlisp
ilmu has quit [Ping timeout: 256 seconds]
cosimone has joined #commonlisp
cage has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
jealousmonk has joined #commonlisp
pranavats has joined #commonlisp
gaqwas has joined #commonlisp
Alfr is now known as Guest2790
Guest2790 has quit [Killed (strontium.libera.chat (Nickname regained by services))]
<opalvaults[m]>
oh thank you jcowan , that's the link I thought I had copied
<opalvaults[m]>
Catie:
<opalvaults[m]>
oops, early return. the man pages are really intuitive
<rotateq>
oh merry lispmas, have to remember that
<opalvaults[m]>
for instance man window gets you information about interaction with the windows manager, etc.
<opalvaults[m]>
merry lispmas :D
<Catie>
Embarassingly, I didn't even think to run "man". I figured Interlisp had some other mnemonic
<jcowan>
Note that you are in a Xerox CL Exec at startup
<opalvaults[m]>
Catie: I was surprised as well!
<opalvaults[m]>
the CL interpreter inside this VM is actually very smart as well
<Catie>
I think it's interesting how much older GUI systems used the right mouse button. We've kind of settled on using left click for most things, but for example scrolling up on the scroll bar is done with a right click. A lot has changed
<opalvaults[m]>
for instance I can define a function that evaluates as soon as it recognizes the last paren.
<Catie>
opalvaults[m]: CL? I thought it was interpreting Interlisp?
<opalvaults[m]>
oh! It might be. I was under the impression that Xerox CL Exec meant that it was an offshoot of CL
<opalvaults[m]>
my misunderstanding if so
jstoddard has joined #commonlisp
<Catie>
Oh no worries! I don't have a great handle on all of this, so I figured I'd ask
<opalvaults[m]>
There was another WM that allowed you to create windows very similarly to how this Interlisp VM does and I can't for the life of me remember it.
<jcowan>
It just means you are in the CL readtable and the XCL user package. There is no law that says `read` has to wait foor a newline.
<jcowan>
opalvaults[m]: Genera, perhaps.
MichaelRaskin has quit [Read error: No route to host]
<opalvaults[m]>
It's actually kind of interesting how much of this technology we still use and take for granted today! This is actually really great. Reminds me a bit of windowmaker on GNU/Linux.
<opalvaults[m]>
Are there any (aside from GUIX) operating systems being currently developed in Lisp?
<Catie>
There's Mezzano
<Catie>
I think that's largely the work of one person though, and I haven't seen an update from her in a while (please correct me if I'm wrong)
<jcowan>
Waiting for newline was an adaptation to conventional TTY drivers.
<opalvaults[m]>
Whoa that's AMAZING
<opalvaults[m]>
Thanks Catie
<Catie>
opalvaults[m]: It's a project I'm very interested in!
<rotateq>
Mezzano is impressive
<Catie>
Oh strong agree, I'm blown away by it
epolanski has quit [Quit: Connection closed for inactivity]
<jcowan>
Both Interlisp and Genera show their origins on the bare metal, and rewriting maiko for bare metal would certainly be possible
<jcowan>
maiko being Japanese foor "microocode"
MichaelRaskin has joined #commonlisp
<jcowan>
Both systems (also MIT Scheme) were born on programmable-microcode shipe. Even now Interlisp has no native compiler.
cage has quit [Ping timeout: 240 seconds]
<jcowan>
s/shipe/chips
<Catie>
Are there major hurdles in compiling to -- for example -- x86?
<jcowan>
Which is also why we don't have Medley working natively on Windows, only through WSL.
<jcowan>
(plus downloading a native X server is just annoying)
<Catie>
I haven't tried it, it always felt like a fool's errand
<jcowan>
We do have an SDL back end, though, so eventually there may be a native Windows build without X
<jcowan>
all Medley wants is a screen buffer
<jcowan>
it does all the compositing itself
cage has joined #commonlisp
treflip has quit [Quit: bye!]
nij- has joined #commonlisp
green__ has joined #commonlisp
miique has quit [Ping timeout: 240 seconds]
atgreen has quit [Ping timeout: 268 seconds]
Algernon666 has quit [Read error: Network is unreachable]
lisp123 has joined #commonlisp
<lisp123>
I read somewhere that LW was better than SBCL for CLOS-related matters, which this (old) set of benchmarks seems to support http://zeniv.linux.org.uk/~ober/clb/
<lisp123>
Is that true?
rito_ has quit [Quit: Leaving]
rain3 has quit [Quit: Leaving]
varjag has joined #commonlisp
cage has quit [Ping timeout: 245 seconds]
<rotateq>
lisp123: when you look at the Franz Inc website "Allegro Common Lisp is the most powerful dynamic object-oriented development system available today, and ..."
<lisp123>
rotateq: ACL looks nice, but currently only looking at LW for its ability to create ObjC shared libraries
<rotateq>
isn't CCL also good at that?
<lisp123>
I think so
<lisp123>
And ECL too I guess
<nij->
A naive question on how CFFI is designed: when I call C within CL, does my code get translated into C-code, passed to C, evaluated there, output passed back, and transformed to a CL data type?
<nij->
Or is it implemented in another way?
<rotateq>
nij-: you load a shared object file INTO your running lisp image :)
<rotateq>
and not write bindings in C but in CL
<nij->
What is a shared object file? And what is a binding..?
<nij->
"*.o"?
<opalvaults[m]>
boring troubleshooting topic, I'm trying to have Nyxt browser load Quicklisp. I have quicklisp added to my .sbclrc file, and a ~/quicklisp directory exists, yet I'm unable to get Nyxt to (ql:quickload 'slynk). Any suggestions?
<rotateq>
erm ok
<opalvaults[m]>
I get WARN - Warning: Error on separate thread: Package QL does not exist. Stream: #
<rotateq>
nij-: when you want to use a foreign lib that lives in a *.o file
<rotateq>
or *.so
<lisp123>
opalvaults[m]: Might be a question for the developers directly, but you can try first making sure. you do all the steps here: https://www.quicklisp.org/beta/
<opalvaults[m]>
cool, i'll take another read through and see if I missed anything
<lisp123>
try #nyxt
<lisp123>
looks like they have a channel
<rotateq>
yesyes
<opalvaults[m]>
I tried there but the one person helping me had to go. I was thinking its more a me and CL issue than with #nyxt directly.
<nij->
opalvaults[m]: By running your CL implementation from the terminal (e.g. `$ sbcl`), does QL get loaded (try `ql:quickload 'slynk'`)?
<rotateq>
it's IRC after all :)
<rotateq>
nij-: there's a wonderful 2h video by baggers about it from which i learned a bit more in the summer
<nij->
rotateq does it talk about how CFFI is designed?
<rotateq>
erm yes
<nij->
!! I wish someone timestamps it. It is sooo long.
<rotateq>
so it's really different again from other approaches
<opalvaults[m]>
nij-: yes that drops me into a slynk prompt
<lisp123>
opalvaults[m]: You can try and see if QL works from a Lisp implementation like SBCL, if so, then perhaps the issue is the nyxt config, if not, then the issue is around QL config (but the link I gave you is pretty much perfect in setting up QL, hence I shared it)
<rotateq>
patience :) I also worked through it
<opalvaults[m]>
okay, i'll keep tinkering and see what is going on. thanks for the help :)
<lisp123>
If slynk works from command line, then perhaps its a nyxt query
<lisp123>
I would raise it with them and see if there is a way they can bundle QL going forward
<nij->
Interesting. I got the same error as opalvaults[m] did.
<nij->
(Never bothered to call slynk in nyxt before though..)
<lisp123>
opalvaults[m]: Try evaluating (load "~/quicklisp/setup.lisp") in nyxt?
<lisp123>
Does that work
<opalvaults[m]>
It was suggested by another user that I load slynk in order to call functions for nyxt inside of Emacs
<opalvaults[m]>
which is why I'm trying to load slynk, so I can manipulate buffers
<rotateq>
even gets to the point to do cheating with it in a castlevania game :D
<opalvaults[m]>
lisp123: it evalautes to T
<lisp123>
ok now try your (ql:quickload 'slynk) command
<opalvaults[m]>
ah, and now (ql: quickload 'slynk) evaluates to (SLYNK)
<opalvaults[m]>
awesome
<lisp123>
This makes me suspect that nyxt is using a different SBCL file / config file
<opalvaults[m]>
I think you're right, I'll ask aartaka in #nyxt. Thanks for helping me troubleshoot that!
<lisp123>
No worries :)
<etimmons>
It's highly unlikely nyxt (or any CL application, really) will load your user unit files
<opalvaults[m]>
Even if it uses SBCL?
<nij->
Or maybe.. if you get nyxt from a package manager, it might pull down another configured CL implementation that doesn't read your config..
<opalvaults[m]>
that could be it. I'm using Guix so maybe it's packaged in such a way
<lisp123>
Glad to see guix getting more popular
<opalvaults[m]>
It's such a smooth experience now.
<nij->
I gave up on guix after trying to package one thing I need for 3 days.
<nij->
opalvaults[m]: :) glad to hear that
<opalvaults[m]>
a bit off-topic, but defintiely the funnest distro I've ever used
<lisp123>
the power of lisp ;)
<opalvaults[m]>
nij-: there are some good examples in the packages repo if you need examples fwiw. that's how I've packaged
<opalvaults[m]>
but thats the last ill say on it here
<etimmons>
opalvaults: yes, even if it uses SBCL. Files like .sbclrc are typically written for dev use. Applications may provide their own way to to user init, but loading .sbclrc is almost certainly the wrong thing to do and has a high chance of causing weird bugs if folks have an esoteric init
<opalvaults[m]>
that's a good point erc. I'll add the ql package init to the nyxt/init.lisp. I believe that's teh way you have to do it in StumpWM as well
<opalvaults[m]>
eric*
* _death
adds (sb-ext:quit) to his ~/.sbclrc
lagash has quit [Ping timeout: 252 seconds]
random-nick has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
gaqwas has joined #commonlisp
jealousm` has joined #commonlisp
jealousmonk has quit [Ping timeout: 260 seconds]
loskutak has joined #commonlisp
lagash has joined #commonlisp
lisp123 has quit [Quit: Leaving...]
waleee has quit [Ping timeout: 252 seconds]
waleee has joined #commonlisp
loskutak has quit [Ping timeout: 240 seconds]
<nij->
I see a quote in py4cl's readme: "It (py4cl) uses streams to communicate with a separate python process, the approach taken by cl4py. This is different to the CFFI approach used by burgled-batteries, but has the same goal." Does anyone know what's the approach mentioned that's used by burgled-batteries?
<etimmons>
nij-: Pretty sure burgled-batteries loads libpython (or whatever it's called) into your CL process
<nij->
By using implementation-dependent #'load-shared-library? I didn't know that we can do that for non-C library (e.g. for SBCL)..
<etimmons>
cython (the canonical python implementation) is written in C
loskutak has joined #commonlisp
loskutak has quit [Quit: WeeChat 3.3]
<phoe>
nij-: no need to use implementation-dependent stuff if you use CFFI which is a compatibility library
shka has quit [Ping timeout: 240 seconds]
nature has quit [Ping timeout: 256 seconds]
<nij->
phoe: Can you use CFFI to talk to python directly, without using other bindings (like cython)?
<phoe>
nij-: talk how exactly
<phoe>
either you load libpython and talk to it via CFFI or you spawn a python process or you talk to it via its standard input/output or network sockets
<phoe>
if you are crazy enough you can try shared or transactional memory for communication, but I don't think it's worth it for python
<phoe>
s/or you talk to it via/and you talk to it via/
<nij->
The second way "to spawn a python process" seems new to me. How does that work?
<rotateq>
ehm starting in shell maybe "python3" or such? :)
<phoe>
nij-: uiop:launch-program
<rotateq>
ah okay or that :D
<opalvaults[m]>
couldn't easily find this info. what is the #p in this expression
<opalvaults[m]>
phoe: I'm very glad common lisp doesn't use port terminology
<opalvaults[m]>
much easier to grok imo
<Xach>
i have had some interesting issues with using strings vs. pathnames when it comes to resolving pathname hosts
<opalvaults[m]>
I was told that you have to use Uiop, and/or implementation specific ways to get a reliable path to $HOME (~), so someone mentioned user-homedir-pathname and I assume that it's pretty unixy?
<opalvaults[m]>
I'm trying to make sure that I'm not going with (load "~/quicklisp/setup.lisp"), as apparently ~ is a bit nebulous to CL (although I was under the impression that ~ is POSIX)
<phoe>
opalvaults[m]: actually it's not unixy, it's a standard CL function
<random-nick>
tilde expansion is usually done by the shell on posix
<phoe>
you can always (merge-pathnames #p"quicklisp/setup.lisp" (user-homedir-pathname)) if you want to be cautious I think
scymtym has quit [Ping timeout: 260 seconds]
<opalvaults[m]>
phoe that's what I used above yeah
<pjb>
opalvaults[m]: I've found that more implementations do the right thing with #P"~/foo" than with "~/foo".
<opalvaults[m]>
however it's not unreasonable to expect POSIX compliance for CL functions right?
<pjb>
but of course, using user-homedir-pathname is the most conforming.
<phoe>
opalvaults[m]: depends on what you mean by POSIX compliance
<Xach>
supporting "~/" is fairly universal these days
<Xach>
i don't think "~<username>/" is but i haven't checked
<opalvaults[m]>
^
<pjb>
opalvaults[m]: yes, it's unfortunately unreasonable, to expect common behavior of CL implementations on POSIX platforms. :-(
<opalvaults[m]>
import os
<opalvaults[m]>
print(os.environ['HOME']), gets the job done in Python, as does expanding ~
<opalvaults[m]>
so if user-homedir=-pathname is similar, that that should suffice
<opalvaults[m]>
user-homedir-pathname*
<etimmons>
nij-: from what you quoted it seems like py4cl uses launch-program or similar to start a separate python process and communicate with it
<phoe>
opalvaults[m]: so does (uiop:getenv "HOME")
<phoe>
but it depends on 1) UIOP, 2) you running on a unixlike system
<opalvaults[m]>
Thankfully I never interact with non-unixlike systems ;p
<opalvaults[m]>
thanks for all the advice ya'll :)
<rotateq>
opalvaults[m]: and if, you can use #+ and #- too for giving extra options (that should be orthogonal to each other in this case)
<random-nick>
I'm pretty sure posix compliance would be to not perform tilde expansion when opening files and the like
<random-nick>
but posix mostly just talks about C functions and not about CL
<random-nick>
so you can't know for sure
<opalvaults[m]>
i'm fairly certain tilde expansion is POSIX
<opalvaults[m]>
now whether CL conforms to that, is another discussion apparently lmao
<random-nick>
that's in the description of the shell language
<opalvaults[m]>
sh is POSIX compliant
<random-nick>
functions on the C side would use functions like open and the like which don't perform tilde expansion
<opalvaults[m]>
-- /bin/sh scripting, more accurately
<random-nick>
and I'm guessing the C interfaces would be more appropriate for mapping to CL's file functions
<opalvaults[m]>
right, however nonetheless tilde expansion is supported in most languages, including POSIX complaint shell
attila_lendvai has quit [Ping timeout: 240 seconds]
<opalvaults[m]>
I'm also unsure I would rely too much on C for just about anything as far as CL is concerned. Relying on standards and specifications is the way imo.
<opalvaults[m]>
Not that I'm in any way authorized to make that claim, but I've coded enough Algol related families and done enough Linux admin to be miffed at a lot of things C does.
<rotateq>
who isn't?
<opalvaults[m]>
after a bit of extra research it appears the scheme family does tilde expansion as well.
<opalvaults[m]>
now I'm curious because I can't find anything in hyperspec, what makes ~ so unreliable in common lisp then?
<rotateq>
opalvaults[m]: and we can have it at readtime with #p before anything out there is messaged
<rotateq>
no, it's one of those things which won't make much sense to specify too precise in the standard, like with say regular expression grammar
<opalvaults[m]>
okay
<opalvaults[m]>
well, learned something new, thanks again all :)
<rotateq>
nice
robin has quit [Quit: Leaving]
<rotateq>
or not specifying at all as it's not a special purpose "close" to hardware thing like C
<phoe>
opalvaults[m]: what if you're running on an OS where ~ does not denote a home directory
<phoe>
but, for instance, something like %HOME% does
<random-nick>
I think CL doesn't specify anything related to tilde expansion because of portability to different systems
<phoe>
it's better to leave stuff like that to implementers rather than hardcode it and risk it becoming obsolete at some point in time
<White_Flame>
you mean like file versions and such?
<random-nick>
yes, single-user systems exist
<opalvaults[m]>
depends on whether or not I'm developing for windows phoe
<random-nick>
White_Flame: well, versioned file systems are back
<random-nick>
but they hide the versions from regular programs
<phoe>
opalvaults[m]: you're developing in CL first and foremost
<opalvaults[m]>
which I would never do, nor would I ever cater to windows users in CL
<phoe>
in the general case, the less OS-specific code you need to have, the better for you
<opalvaults[m]>
it's kind of off-topic, but windows is the only ones that uses %% to specify home directory as an environmental variable
<phoe>
and lots of OS-specific code already made it into the compatibility library that UIOP is
<random-nick>
CL doesn't even specify what's the path separator
<opalvaults[m]>
right, would would make sense in otherl anguages as well like python's os module.
<opalvaults[m]>
so if uiop has that functionality and is standardized I don't see any reason not to use it
<phoe>
standardized? that's some strong words out there
<opalvaults[m]>
i'm looking for reliable methodology
<phoe>
more like "everyone uses it because it's seemingly the lesser-est evil"
<opalvaults[m]>
I don't see your point.
<random-nick>
yeah I'd rather use "widely adopted" than "standardized"
<phoe>
UIOP doesn't have a standard
<White_Flame>
or at the most, "ad hoc standard"
<opalvaults[m]>
POSIX specifications allow for expansion of the tilde into $HOME
<phoe>
there's no document that says how it should work
<opalvaults[m]>
If that's not a standard, then I'm unsure what is.
<phoe>
unlike, for example, CL
<phoe>
POSIX is a standard, it's a document
<phoe>
so is ANSI CL
<opalvaults[m]>
So does ANSI CL have a reliable methodology for detemrining $HOME? or expanding variables to point to it?
<phoe>
linux is an implementation of POSIX in a way, just like SBCL is an implementation of CL
<phoe>
no, it doesn't
<opalvaults[m]>
Okay then
<phoe>
it doesn't have a notion of environment variables
<pjb>
It doesn't say that random program should do it. In particular, open("~/foo",O_RDONLY) definitely DOES NOT expand the tilde !!!
<phoe>
it only has user-homedir-pathname which is equivalent to $HOME, but nothing for other environment variables
<pjb>
It's NOT a feature of the kernel.
<pjb>
POSIX only specifies it for the shell.
<opalvaults[m]>
I don't see how its' relevant. The practical matter is that if someone needs a reliable methodology to point to $HOME, or %HOME%, or what have you, it's not quite unreasonable to expect a language to implement it
<rotateq>
opalvaults[m]: but it can be completely different from one day to another
<opalvaults[m]>
POSIX specifies it is allowed period. If it wasn't allowed, you wouldn't be able to do it in the shell. It's a reliable method if pointing an environment to a specific filesystem directory correct?
<phoe>
since ANSI CL is from 1994, UIOP and other compatibility libraries have a lot of stuff that is commonly used and differs between OSes and implementations but isn't a part of ANSI CL
<pjb>
opalvaults[m]: no, not a language, that was specified to work on different systems!
<phoe>
that's the CL way
<rotateq>
so it's about have something that stands the test of time really
<pjb>
opalvaults[m]: you may ask it from specific implementations.
<random-nick>
pjb: that was my point, POSIX specifies tilde expansion only in the shell language
<pjb>
opalvaults[m]: but not from the language.
<opalvaults[m]>
s/shell//bin/sh
<pjb>
opalvaults[m]: note how the C language has no way to get a HOME or doesn't specify a structure in the path strings!
<rotateq>
even on non register-based machines we mostly have today
<opalvaults[m]>
I may ask the most reliable methodology in CL so that I don't create bugs where (user-homedir-pathname) doesn't resolve to rubbish on unix operating systems.
<pjb>
opalvaults[m]: it's not the job of C, the language, to do that.
<opalvaults[m]>
I think I said before, but almost every language has this. I'm aware C does not, but I don't care whata specific language does or doesn't do.
<opalvaults[m]>
I just want to know what won't break things for other users.
atgreen has joined #commonlisp
<pjb>
opalvaults[m]: CL implementations provide FFI, and you can therefore link to the getenv and putenv posix library functions. #+ccl (ccl:getenv "HOME") #| --> "/Users/pjb" |#
<phoe>
opalvaults[m]: u-h-p won't resolve to rubbish - if it does, you are free to file a bug with the implementation :D
<opalvaults[m]>
Or cause issues further down the road.
<rotateq>
but what you said may make sense in a language which has just one impl and its spec is bound to that directly :)
<phoe>
the standard specifies that the definition of a home directory is implementation-dependent, but "defined in Common Lisp to mean the directory where the user keeps personal files such as initialization files and mail."
<phoe>
so $HOME on all unices all right
<opalvaults[m]>
right, i've already read that phoe as we discussed it far further up.
<phoe>
you can use the UIOP's XDG functions if you want, too
green__ has quit [Ping timeout: 240 seconds]
<random-nick>
other languages probably don't perform parameter expansion and other parts of shell expansion, so bringing up posix is a weird point
<opalvaults[m]>
However, it still begs the question why CL decides to buck the trend of reliable tilde expansion
<opalvaults[m]>
I suppose it's an artifact of its time?
<opalvaults[m]>
I think there's no shame in admitting that.
<opalvaults[m]>
yes they do random-nick.
<opalvaults[m]>
even scheme does it.
<opalvaults[m]>
the least portable language in the world
<opalvaults[m]>
tm
<phoe>
opalvaults[m]: huh
<phoe>
does C perform tilde expansion? I haven't heard of it doing it
green__ has joined #commonlisp
<phoe>
it would mean that C is also the least portable language in the world
<random-nick>
from r6rs: Some of the procedures described in this chapter accept a file name as an argument. Valid values for such a file name include strings that name a file using the native notation of filesystem paths on an implementation's underlying operating system, and may include implementation-dependent values as well.
<random-nick>
seems that scheme doesn't specify tilde expansion in the specification either
<phoe>
but, to answer your question: standard CL does not expand tildes because standard CL has no notion of tildes
<phoe>
it leaves lots of pathname stuff to be defined by implementations themselves
<opalvaults[m]>
C does not, but as I poitned out many times before I don't think any language shoudl model itself after C :P
<phoe>
so, any sort of tilde expansion, too
<opalvaults[m]>
No it doesn't phoe. That's a weird conclusino you've drawn lmao
<phoe>
so, for tilde expansion and such, query your implementation
<phoe>
which Lisp implementation do you use?
<random-nick>
also, CL doesn't "buck the trend" if the trend is newer than CL
<opalvaults[m]>
random-nick:
<opalvaults[m]>
If STRING is identical to "~" or if it begins with "~/", return the argument with the "~" substituted by the current user's home directory. If the current user cannot be determined or does not exist, a condition of type (exn pathname-expand username) is raised.
<opalvaults[m]>
If STRING begins with "~USERNAME", return the argument with the "~USERNAME" substituted by the provided user's HOME directory. On Windows, this will be the value of the environment variables USERPROFILE or HOME (or "." if none of the variables is set). On Unix systems, the user database is consulted. If the user does not exist, a condition of type (exn pathname-expand username) is raised.
<random-nick>
is that from another rnrs or is that from a particular rnrs implementation's documentation?
<opalvaults[m]>
CL doesn't change to match the landscape? Stuck in the past?
atgreen has quit [Ping timeout: 268 seconds]
<phoe>
the standard is stuck in 1994, yes, and the implementations and compatibility libraries take over from there
<phoe>
lots of pathname stuffs are implementation-dependent, so implementation manuals like this is what you should be consulting when it comes to implementation-dependent behavior
green__ has quit [Ping timeout: 240 seconds]
<opalvaults[m]>
:home is represented in namestrings by ~/ and (:home "username" by ~username/ at the start of the namestring. Tilde-characters elsewhere in namestrings represent themselves.
<opalvaults[m]>
Using (:home "user") form on Windows signals an error.
<opalvaults[m]>
Home directory specifiers are resolved to home directory of the current or specified user by native-namestring, which is used by the implementation to translate pathnames before passing them on to operating system specific routines.
<opalvaults[m]>
ah! so tildes are okay then
<phoe>
yes, that's what I've been trying to convey
<opalvaults[m]>
thanks SBCL
<phoe>
the ANSI CL standard doesn't care about tildes, it says it's implementation-defined stuff
<phoe>
so SBCL defines it
<opalvaults[m]>
well then cool, i'm glad SBCL defines tilde expansion normally
<phoe>
as it was said somewhere above, most implementations do
<phoe>
(it was Xach, probably, like 50 minutes ago?... :D)
<opalvaults[m]>
ah, but it was told do me that tilde was unreliable. a point that is only just now being refuted by SBCL
<opalvaults[m]>
I was asking for reliable methodology.
<pjb>
opalvaults[m]: CL defines logical pathnames. You can define a logical host named HOME with translations to the user home directory. SO you can use logical pathnames suchas : #P"HOME:QUICKLISP;SETUP.LISP"
<phoe>
the way to achieve reliability in the CL world is to check which implementations are consistent in their implementation-defined behavior
<phoe>
so check if tildes are expanded the proper way in the most commonly used implementations, and you're golden
<pjb>
opalvaults[m]: these logical path will work everywhere, as long as you provide the logical pathname translation.\
<opalvaults[m]>
which is quite nice pjb
<phoe>
and wherever they don't work the same way, write a compatibility library that provides a uniform API
<phoe>
that's how sockets, threads, and other stuff works nowadays in the CL world.
<opalvaults[m]>
in the SBCL CL world?
<phoe>
no, in the CL world
<phoe>
which can use - and uses - SBCL, CCL, ECL, Clasp, ABCL, CLISP, ACL, and LW
<phoe>
it's broader than just SBCL.
<opalvaults[m]>
So wait doesn't having x number of implementations kind of defeat the purpose of standardizatino?
<phoe>
on another note, my amb implementation/tests/manual is sorta ready for first public reviews - https://github.com/phoe/amb
<opalvaults[m]>
wow i really cannot do the "ion" lmao
<phoe>
opalvaults[m]: what do you mean, defeat
<phoe>
if your code is portable ANSI CL then it runs on every of those implementations
<pjb>
opalvaults[m]: standardization defines a common set. It's necessarily limited. Implementations define a superset.
<pjb>
Each implementation define its own superset.
<phoe>
doesn't having x C compilers defeat the purpose of standardizing C?
<random-nick>
Shinmera made a site which lists some portability libraries and their status on various CL implementations: https://portability.cl/
varjag has quit [Ping timeout: 268 seconds]
<opalvaults[m]>
phoe: are there non POSIX compliant C implementations?
<opalvaults[m]>
I'm not aware of any compiler that doesn't conform to at least some standard
<opalvaults[m]>
ie ISO C/POSIX etc
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
<opalvaults[m]>
that's a cool chart random-nick
<random-nick>
I've heard there are many niche embedded microprocessors which have a very poor ad-hoc C implementation as the only available programming language
<random-nick>
but I haven't personally done any embedded programming so I don't know from experience
<opalvaults[m]>
Which kind of nicely goes back to your original question of asking what if a users home was %HOME%. that's not what I'd ever be concerned about, to answer your question.
<phoe>
well, obviously, if you assume that your code only runs on unices then don't be surprised when people complain it only runs on unices
<opalvaults[m]>
I don't develop, or use non-free software
<opalvaults[m]>
I'm not concerned with Windows users (or Unix users) that complain that whatever I write isn't cross-platform with their proprietary software.
<jcowan>
Vacietis is the World's Most Awesome C Compiler, but its standards compliance is a bit technical: sizeof(char) = sizeof(int) = sizeof(long) = sizeof(double) = 1.
<opalvaults[m]>
I perhaps should have communicated that I'm looking for reliable methodology for Unix systems, and for that I apologize for not being clear from the onset.
<phoe>
I'm kinda sad that you conflate "free software" with "unix" - we have Mezzano around :(
<random-nick>
the home directory on mezzano is a little weird if I recall correctly
<random-nick>
it's a single user system so there's just one
<random-nick>
and it's stored on an in-memory file system
<opalvaults[m]>
random-nick: is this done by the CLOSOS fellow?
<opalvaults[m]>
Mezzano*
<phoe>
random-nick: nope, CLOSOS is a different thing
<opalvaults[m]>
Because that was in a paper I swear I link every 5 second
<phoe>
although the concepts are similar, obviously
<phoe>
CLOSOS is Robert Strandh's thing, he goes by beach around here
<phoe>
whereas mezzano is a project by froggey
<opalvaults[m]>
ah, gotcha.
<random-nick>
opalvaults[m]: no, Mezzano is froggey's personal project with some contributors you'll find in #mezzano
<opalvaults[m]>
okay well what was a configuration setting in Nyxt turned out to be a whole discussion and I thank everyone for teaching me a bunch of new things about common lisp
<random-nick>
mezzano differs a lot from CLOSOS if I recall the CLOSOS document correctly
<random-nick>
being single user, having a hierarchical filesystem, using a (concurrent ml like?) event abstraction for IO and being more of a traditional CL implementation than SICL
azimut has quit [Ping timeout: 276 seconds]
<random-nick>
well not only for IO but for all synchronisation
<opalvaults[m]>
I may have to spin Mezzano at some point. The CLOSOS paper was an incredible read, so to tinker with current implementations of Lispy OS's could be a cool rabbit-hole
fmakuncertain has joined #commonlisp
<opalvaults[m]>
also, I've forked the UltraSpec project as its currrently unmaintained. Is it a worthwhile endeavor to fix the repository? Does anyone think it would gather community participation?
<opalvaults[m]>
I'm not aware of anything except the proprietary HyperSpec and the book ANSI Common Lisp that is used as reference for CL
<opalvaults[m]>
Someone here may enlighten me to projects that have already done so in the FLOSS-sphere.
<random-nick>
there's the well specified common lisp project which aims to clarify the spec
<random-nick>
you should also checkout the online lisp meeting video about the spec
<opalvaults[m]>
What is thie well specified common lisp project?
<opalvaults[m]>
I'm a little confused. The original UltraSpec used Tex documents and became a mess. I'm assuming as sthat meeting was really, really new that it's something that's already underway and about to be released.
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
fmakuncertain has quit [Remote host closed the connection]
fmakuncertain has joined #commonlisp
<phoe>
ultraspec was done too happily and I burned out on it badly
<phoe>
scymtym's work has much better foundations than I did, thankfully
fmakuncertain has quit [Ping timeout: 256 seconds]
<opalvaults[m]>
ah phoe , i should have recognized the username