<epony>
pfdietz_ now, also some calculators have this problem.
dxtr has joined #lisp
Kundry_Wag has joined #lisp
paul0 has joined #lisp
JohanP has joined #lisp
dented42 has joined #lisp
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
josh has joined #lisp
josh is now known as Guest83816
dxtr has quit [Quit: leaving]
Guest83816 has quit [Remote host closed the connection]
JohanP has quit [Ping timeout: 260 seconds]
Guest83816 has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
josh_ has joined #lisp
Guest83816 has quit [Ping timeout: 260 seconds]
markong has quit [Ping timeout: 265 seconds]
Tristam has joined #lisp
JohanP has joined #lisp
dxtr has joined #lisp
JohanP has quit [Ping timeout: 264 seconds]
wxie has joined #lisp
t0adst00l has quit [Remote host closed the connection]
d4ryus1 has joined #lisp
pjb has quit [Ping timeout: 255 seconds]
d4ryus has quit [Ping timeout: 248 seconds]
doanyway has quit [Remote host closed the connection]
JohanP has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
t0adst00l has joined #lisp
JohanP has quit [Ping timeout: 268 seconds]
t0adst00l has quit [Ping timeout: 255 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
damke has joined #lisp
Lord_Nightmare has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
fisxoj has quit [Quit: fisxoj]
Lord_Nightmare has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fisxoj has joined #lisp
dented42 has joined #lisp
josh_ has quit [Ping timeout: 240 seconds]
JohanP has joined #lisp
ioa has quit [Read error: Connection reset by peer]
kolb has quit [Read error: Connection reset by peer]
ioa has joined #lisp
pierpal has joined #lisp
mrottenkolber has joined #lisp
mrottenkolber is now known as Guest88262
eli_oat has quit [Quit: Leaving.]
dddddd has quit [Remote host closed the connection]
JohanP has quit [Remote host closed the connection]
JohanP has joined #lisp
aindilis has joined #lisp
<pierpa>
"My advisor (Dan Friedman) used to express it like this in the 1980s: \"Software crisis? What software crisis? Just put all programmers in front of a Lisp machine and your crisis is over.\"" -- Matthias Felleisen, 1 hour ago.
JohanP has quit [Ping timeout: 260 seconds]
Mutex7 has quit [Remote host closed the connection]
damke_ has joined #lisp
MasouDa has quit [Ping timeout: 256 seconds]
damke has quit [Ping timeout: 264 seconds]
<pfdietz_>
If only that were true. :)
elderK has joined #lisp
karswell has quit [Ping timeout: 248 seconds]
MasouDa has joined #lisp
aindilis has quit [Ping timeout: 264 seconds]
JohanP has joined #lisp
aindilis has joined #lisp
shifty has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
<pierpa>
(MFs point, though, is that at the time they were wrong. He wrote this in a rant *against* Lisp Machines style of developing software)
<pierpa>
basically, he's against the REPL as we know it.
doanyway has joined #lisp
MasouDa has quit [Ping timeout: 240 seconds]
matijja has quit [Ping timeout: 260 seconds]
JohanP has joined #lisp
comborico1611 has joined #lisp
yoel has joined #lisp
JohanP has quit [Ping timeout: 248 seconds]
JohanP has joined #lisp
yoel has quit [Ping timeout: 248 seconds]
JohanP has quit [Ping timeout: 264 seconds]
beach has quit [Ping timeout: 256 seconds]
JohanP has joined #lisp
jack_rabbit has quit [Ping timeout: 276 seconds]
schoppenhauer has quit [Ping timeout: 256 seconds]
schoppenhauer has joined #lisp
pierpa has quit [Quit: Page closed]
JohanP has quit [Ping timeout: 240 seconds]
comborico1611 has quit [Ping timeout: 248 seconds]
johnvonneumann_ has joined #lisp
fisxoj has quit [Quit: fisxoj]
jack_rabbit has joined #lisp
johnvonneumann has quit [Ping timeout: 240 seconds]
sellout- has joined #lisp
sellout-1 has quit [Ping timeout: 264 seconds]
aindilis has quit [Remote host closed the connection]
Pixel_Outlaw has quit [Quit: Leaving]
JohanP has joined #lisp
aindilis has joined #lisp
shka has joined #lisp
JohanP has quit [Ping timeout: 268 seconds]
fisxoj has joined #lisp
varjag has joined #lisp
xrash has joined #lisp
shrdlu68 has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
johnvonneumann_ has quit [Read error: Connection reset by peer]
johnvonneumann_ has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
ealfonso has joined #lisp
<ealfonso>
I'm trying to debug a condition raised in my hunchentoot , but I don't want to resort to print statements when I have slime. Is there a way to get backtraces from hunchentoot handlers in slime?
JohanP has joined #lisp
<shrdlu68>
Did LispMachines of old have system calls as we know them today? I'm trying to gain perspective on whether it would be possible/desirable to expose the OS's API by some other means, perhaps through a pseudo-filesystem of network.
<p_l>
they didn't
JohanP has quit [Ping timeout: 240 seconds]
<p_l>
in fact, they didn't even have system calls in CP/M classic style, or MVS OS
<p_l>
what the oldest of them had was multi-threaded VM lying deep inside the CPU that handled some of the work in a way that could be considered "syscalls", but more adequately formed the "Virtual Machine" in which the code lived
josh_ has joined #lisp
<shrdlu68>
p_l: I see.
<p_l>
pretty much everything was done through plain function calls
<p_l>
I guess AmigaOS and AtariOS (of the 8bit fame) could be considered similar
<p_l>
also classic windows pre 4.x (i.e. 1.01 - 3.x) which was implemented essentially as a bunch of shared libraries you linked with
<p_l>
(maybe partially classic MacOS?)
beach has joined #lisp
<shrdlu68>
I'm wondering whether it would make sense to expose syscalls in Linux in some other way, such that one doesn't have to rely in C/Assembly to interface with the kernel.
<shrdlu68>
s/rely in/rely on/
<beach>
Good morning everyone!
<shrdlu68>
Morning beach!
<p_l>
shrdlu68: well, you need to do the actual call. Though VDSO kinda does exactly that, for some specialized calls that don't actually do any context switch
<p_l>
beach: 'morning
<shrdlu68>
p_l: Yes, I'm thinking of writing a kernel module or something similar.
<p_l>
shrdlu68: also, several systems had language-agnostic call interfaces, it's more of an Unix thing that brought C-defined interfaces itno life
<p_l>
for example, Windows has no official syscalls
<shrdlu68>
p_l: I'm looking for such material to read (language-agnostic call interfaces).
<p_l>
shrdlu68: the documentation for VMS should be still out there on HP webservers, it was one of the more language agnostic systems
<p_l>
MVS (now called z/OS) is old enough to not care, and had significant amount of code written to this day in assembly
<p_l>
While a lot of windows is now in C land, the COM system is *heavily* used to provide API and handle ABIs
<p_l>
especially since you can't depend on such silly things as malloc() and free() being the same for two different libs
cmbntr has joined #lisp
igemnace has joined #lisp
<p_l>
L4 and pure Mach-based systems technically have IDL you want to use
<p_l>
hmm
<p_l>
I *suspect* AS/400 (now called IBM i) might have Lisp Machine-style lack of system calls across all languages outside of the POSIX environmnet
<p_l>
but that's because it has capability-style addressing, so calling a function might actually trigger apropriate security measures
<beach>
p_l: I am impressed by your knowledge of such things.
<p_l>
beach: I call it
<p_l>
"a legacy of misspent youth"
<beach>
Heh! Still, very useful stuff to know.
<p_l>
sometimes, yes
<p_l>
and definitely eye-opening to wider world of computing
<p_l>
I do sometimes envy the people who got to actually experience or build the things I only got to read about or use emulators for
<p_l>
shrdlu68: oh, there's one system you might want to look at
<p_l>
combining both direct function calling *and* filesystem-based APIs
<p_l>
Bell Labs (now VituaNova) Inferno
<beach>
p_l: I can see that. So how about you help build a LispOS according to my specification? Then you would be part of something like that.
<p_l>
beach: it's something I've been doodling about from time to time, actually
<beach>
If I had your knowledge, I would be greatly tempted.
<shrdlu68>
beach: Yes, this is interesting. Is the POSIX api language-agnostic?
<beach>
shrdlu68: Not at all. This specification is for Common Lisp only.
<beach>
shrdlu68: Sorry.
<p_l>
beach: I ... just thought it might be a fine PhD project
<beach>
Oh, very definitely so.
<beach>
When do you plan to do your PhD project?
<p_l>
hard to say. Current priorities involve paying off debts ASAP, in order to free up capital for a planned move to france
<beach>
Wow.
<shrdlu68>
beach: I see, this is part of your LispOS project.
<beach>
Life-changing decisions there.
<antoszka>
p_l: Move to Bordeaux then and you'll get a chance to do your phd with beach :)
<p_l>
beach: girlfriend likes warm climates, wants spacious area far away from people and a big house :)
<beach>
shrdlu68: Not really, no. For my LispOS project I don't plan to have anything POSIX like.
<p_l>
beach: generally, looking at Dordogne area
<beach>
antoszka: 'fraid not. I am about to retire, so I don't take on PhDs anymore.
<beach>
p_l: Oh, yes, very nice.
<antoszka>
beach: I see.
ealfonso has quit [Ping timeout: 255 seconds]
<shrdlu68>
beach: I'm not sure I understand the document. I'm thinking of writing a kernel module that would facilitate language-agnostic syscalls in the Linux kernel. Is this something like that?
Lord_Nightmare2 has joined #lisp
<p_l>
beach: doesn't mean you can't collaborate (or review) papers, right? :)
doanyway has quit [Remote host closed the connection]
<beach>
shrdlu68: No, probably not. I might have misled you.
<p_l>
tbqh, I'd like to start by re-learning paper writing
<beach>
p_l: I definitely plan to continue to write and review papers.
<shrdlu68>
beach: Not at all. But does my plan make any sense to you?
Lord_Nightmare has quit [Ping timeout: 263 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
<beach>
shrdlu68: I would need more time to think about it. I haven't had my coffee yet, and it is still early in the morning. :)
vtomole has joined #lisp
<p_l>
shrdlu68: ahh, one more interesting thing to read, possibly, is classic x86 segmentation and permission handling involved
<shrdlu68>
beach: Cool, I'll be around if you think of anything later.
<vtomole>
Why does (apply '+ '(1 2))=> 3 and (apply 'and '(1 NIL)) =>The function COMMON-LISP:AND is undefined.?
<p_l>
shrdlu68: I haven't looked at it in a long time, but it had "call gates" which controlled how you could call from different "modules" with different permission levels
<beach>
vtomole: AND is a macro, so can't be used with APPLY.
<vtomole>
Ah. Damn.
<beach>
p_l: Yeah, it looks like x86 was trying to emulate Multics in that respect.
<josh_>
but you can use every #'identity for a similar effect!
<rme>
vtomole: you can use cl:every
<beach>
vtomole: There are functions that do similar things, like EVERY and SOME.
<shrdlu68>
p_l: You've left me with enough material for a lot of reading. Does what I'm planning make sense?
<p_l>
shrdlu68: not sure. The fun is in figuring it out
<p_l>
I have a bit more pragmatic streak so I always look into things like security model and dealing with both having restricted system *and* hackable system
<p_l>
Lisp machines went towards extreme in "hackable" system
<shrdlu68>
I guess what I'm wondering is why this has not been done before. I was inspired by namespaces and cgroups in Linux. The former is implemented in syscalls while the latter is implemented through a pseudo-filesystem.
<p_l>
shrdlu68: funnily enough, both namespaces and use of pseudo-filesystems the way cgroups are done come from the same OS
<shrdlu68>
I ahve thought about security a little, not sure how my module would play nice with things like seccomp.
<p_l>
and there's documented reasoning behind which parts are done through system call and which through exported filesystem
<p_l>
the specific OS in this case is Plan9
<p_l>
which had *very* strong separation of what was kernel and user space, yet at the same time mixed the actual programming model in weird way
JohanP has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
<vtomole>
beach: Ok thanks
<antoszka>
p_l: How close is current Inferno to the original plan9 ideas?
<antoszka>
p_l: BTW, are/were there any ANSI CL implementations for either OS?
<p_l>
they are very close but separate implementations of similar ideas, and generally speaking are interoperable to great degree (as Plan9 4thEd and Inferno had resynced their protocol implementations)
<antoszka>
but was Inferno rewritten from scratch? Or was it just a "new version" with stuff added/partly rewritten and so on?
JohanP has quit [Ping timeout: 240 seconds]
surya has joined #lisp
<p_l>
it was a completely new OS that happens to be from related if not same team and which targeted Java as competitor
<antoszka>
yeah, I can see it was written mostly in Limbo, which is kinda a remake of p9's Alef, right?
<antoszka>
What about the Lisps there?
<p_l>
there's afaik no Lisp that runs on Dis (the Inferno VM)
<p_l>
there were *some* lisp implementations on Plan9
<p_l>
and theoretically it's doable to port ECL and even SBCL to it
himmAllRight17 has quit [Ping timeout: 255 seconds]
himmAllRight17 has joined #lisp
<p_l>
arguably Inferno is one of the more recent "language OSes" but which tries to abstract the underlying hw fully
<antoszka>
p_l: Is it actually being used commercially in any areas?
surya has quit [Read error: Connection reset by peer]
<p_l>
Plan 9 was used as the "firmware" in Coraid storage platforms
<p_l>
Inferno was used in some VoIP stuff, but details are hard to find
<p_l>
Plan 9 was also used not exactly commercially in grid computing efforts and at least one supercomputer
<p_l>
bunch of interesting research projects on both, though
<p_l>
like Plan B and Omero
<antoszka>
p_l: Doesn't Inferno fill a similar niche to Erlang based systems? I know this is a different level of abstraction (OS + lang + runtime) vs (any-OS + lang + runtime).
<p_l>
the main difference is that Inferno comes with ready-made bare-metal kernel
<p_l>
with exception of one closed-source, bare-metal erlang is long dead
pierpal has quit [Read error: Connection reset by peer]
<p_l>
(doesn't mean it has to stay that way)
<antoszka>
yeah, so that's what I said, but anyway, guess that's a topic for #lispcafe, so i'll shup up here for now :)
asarch has quit [Quit: Leaving]
yoel has joined #lisp
yoel has quit [Ping timeout: 260 seconds]
fisxoj has quit [Ping timeout: 264 seconds]
surya has joined #lisp
JohanP has joined #lisp
<drmeister>
Say you have a list of N jobs on a machine with M logical processors (N > M) - does anyone have an elegant way to keep all M logical processors busy until the N jobs are done?
sjl has quit [Quit: WeeChat 1.9.1]
JohanP has quit [Ping timeout: 248 seconds]
<beach>
Pick an arbitrary subset of M out of N jobs. When a job finishes, select one of the remaining ones to put on that processor.
JohanP has joined #lisp
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<drmeister>
I guess the devil is in the details - how do I know when a job finishes using say Bordeaux threads? thread-alive-p? condition-variable.
<drmeister>
?
<drmeister>
I think it's too late - I can't think straight. I'll try again tomorrow.
JohanP has quit [Ping timeout: 256 seconds]
<shrdlu68>
drmeister: You could use locks, such that running threads block execution, and when they finish they reklease the lock and allow the other jobs to run.
<p_l>
drmeister: you could create M execution threads that pick lambdas to execute from a queue
<p_l>
however you might have to ensure that there's no blocking calls, or possibly move them to a different thread
<pillton>
Or you could measure business.
<pillton>
Or is it busy-ness?
ealfonso has joined #lisp
<p_l>
well, there are more complex algorithms, yes
<p_l>
one could mix together Petalisp with ideas of IBM MVS, and optimize the I/O pathways *upfront* and only release the process to execution with I/O pretty much all queued to run
<jasom>
drmeister: Have a queue of jobs; spawn 4 threads that pull from that queue.
<beach>
Plus, your indentation is wrong. You must not be using the SLIME-INDENTATION contribution.
<beach>
What does it mean to "merge two structs"?
<beach>
And, it looks like you are using CLASS-DIRECT-SLOTS, MAKE-INSTANCE and such that are not defined for structs.
<beach>
SLOT-VALUE.
JohanP has quit [Remote host closed the connection]
JohanP has joined #lisp
<beach>
And you use IF with only a `then' branch that is also negated. In such cases, it is better to use UNLESS.
<beach>
Oh, and another with a normal `then' branch. Then it is better to use WHEN.
<ealfonso>
beach I'm using it with a struct and it worked, and CLASS-DIRECT-SLOTS, MAKE-INSTANCE did work
<ealfonso>
beach I have a config struct with many slots, and I need to default nil values to default ones
<beach>
ealfonso: Common Lisp is not defined by what works in a particular implementation, but by what the Common Lisp HyperSpec says.
<beach>
ealfonso: But, sure, if you want your code to work only in a particular implementation, you can use whatever works in it. But you didn't say that, so I am giving you feedback with respect to the language specification.
<beach>
ealfonso: If I were you, I would not use structs in the first place. I would use standard instances instead.
JohanP has quit [Remote host closed the connection]
<beach>
ealfonso: And I would use CLOSER-MOP rather than SBCL-specific MOP functionality.
JohanP has joined #lisp
earl-ducaine has quit [Remote host closed the connection]
<antoszka>
drmeister: doesn't lparallel manage that automatically when you create an appropriate kernel?
<ealfonso>
I guess I was wondering if there is a more standard way of doing something like this
<beach>
ealfonso: For one thing, I don't see the reason to use a macro.
<ealfonso>
beach that's true
<antoszka>
drmeister: BTW, did you guys get to the US without problems? (i'm the guy you met at the airport :))
<beach>
ealfonso: Furthermore, when you work with standard instances, you have functionality at your disposal that, while not in the Common Lisp HyperSpec, is more consistent across implementations than when you work with structs.
surya has quit [Ping timeout: 255 seconds]
al-damiri has quit [Quit: Connection closed for inactivity]
JohanP has quit [Remote host closed the connection]
JohanP has joined #lisp
<ealfonso>
beach thanks for the feedback. I turned it into a function and got SLIME-INDENTATION. I don't really care about other implementations for now
d4ryus1 is now known as d4ryus
JohanP has quit [Ping timeout: 264 seconds]
<phoe>
drmeister: if you want threads and just that, use BORDEAUX-THREADS; if you want to get actual work done, use LPARALLEL
<aeth>
eh
<pillton>
Depending on the problem it might be worth structuring your computation to work with schedulers like SLURM or Sun Grid Engine.
<aeth>
If you only use low-level libraries like bt you're probably going to reinvent things, but you're probably going to reinvent them exactly to your specifications, whereas higher-level libraries are going to do things you don't like.
<aeth>
So it's about time saved vs. control
<aeth>
No right answer imo
surya has joined #lisp
<aeth>
s/No right answer/No one correct answer for everyone/
shrdlu68 has quit [Ping timeout: 240 seconds]
vlatkoB has joined #lisp
JohanP has joined #lisp
Cymew has joined #lisp
fisxoj has joined #lisp
JohanP has quit [Ping timeout: 265 seconds]
surya has quit [Read error: Connection reset by peer]
Bindler has quit [Ping timeout: 256 seconds]
JohanP has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
matijja has joined #lisp
JohanP has quit [Client Quit]
vtomole has quit [Ping timeout: 260 seconds]
Bindler has joined #lisp
pagnol has joined #lisp
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
surya has joined #lisp
ealfonso has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
yoel has joined #lisp
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
SuperJen has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
yoel has quit [Ping timeout: 248 seconds]
quazimodo has quit [Ping timeout: 248 seconds]
JenElizabeth has quit [Ping timeout: 256 seconds]
lyding has quit [Ping timeout: 276 seconds]
pdv has joined #lisp
quazimodo has joined #lisp
lyding has joined #lisp
markong has joined #lisp
Ukari has joined #lisp
beach` has joined #lisp
josh_ has quit [Ping timeout: 276 seconds]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
zymurgy has quit [Quit: WeeChat 1.4]
shrdlu68 has joined #lisp
zymurgy has joined #lisp
beach has quit [Ping timeout: 256 seconds]
nowhere_man has quit [Ping timeout: 240 seconds]
mlf|2 has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
mflem has quit [Ping timeout: 246 seconds]
surya has quit [Read error: Connection reset by peer]
rippa has joined #lisp
angavrilov has joined #lisp
random-nick has joined #lisp
beach` is now known as beach
terpri has joined #lisp
nika_ has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
surya has joined #lisp
scymtym has joined #lisp
elfmacs has joined #lisp
pierpal has joined #lisp
Bindler has quit [Read error: Connection reset by peer]
vlatkoB_ has joined #lisp
pierpal has quit [Client Quit]
pierpal has joined #lisp
vlatkoB has quit [Ping timeout: 265 seconds]
aindilis has quit [Remote host closed the connection]
shrdlu68 has quit [Quit: Lost terminal]
heisig has joined #lisp
aindilis has joined #lisp
aindilis has quit [Remote host closed the connection]
elderK has quit [Ping timeout: 260 seconds]
aindilis has joined #lisp
elderK has joined #lisp
aindilis has quit [Remote host closed the connection]
damke has joined #lisp
aindilis has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
energizer has quit [Quit: Leaving]
Anthaas has quit [Ping timeout: 268 seconds]
fraya has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
meh has joined #lisp
Anthaas has joined #lisp
surya_ has joined #lisp
surya has quit [Read error: Connection reset by peer]
<borodust>
I nailed it down to (ql::matching-directory-files "~/quicklisp/local-projects/" (lambda (file) t)) returning different results for sbcl and ccl
<borodust>
ccl returns only top-level directories of local-projects
Ukari has quit [Remote host closed the connection]
markong has quit [Ping timeout: 255 seconds]
yoel has quit [Ping timeout: 276 seconds]
elfmacs has quit [Ping timeout: 265 seconds]
light2yellow has joined #lisp
elfmacs has joined #lisp
<borodust>
Xach: ah, i see why :/ ccl's directory-entries calls merge-pathnames with :follow-links nil
<borodust>
i wonder how that worked earlier for me or did it even :/
<jackdaniel>
borodust: not a solution, but a workaround: issuing ql:register-local-projects from sbcl should make things work on ccl too
SenasOzys has quit [Ping timeout: 240 seconds]
<borodust>
jackdaniel: yeah i did that so far this way, but i use #'write-asdf-manifest-file and call to it overwrite system-index.txt :/
Ukari has joined #lisp
damke has joined #lisp
Cymew has quit [Remote host closed the connection]
ghard`` has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
<light2yellow>
is there a way to splice a list without comma and comma-at? for example, how do I create (a 1 2 3 c) if (setq b '(1 2 3)) ? what would be the equvalent of `(a ,@b c) ?
<ecraven>
light2yellow: expand the backquote, look how it constructs the result
<light2yellow>
ecraven: you mean with macroexpand?
<ecraven>
(cons 'a (append b '(c)))
<ecraven>
yes
<jackdaniel>
(append (list a) b (list c))
<jackdaniel>
well, not list in your case I suppose
<jackdaniel>
either way, what do you want to achieve? (like a high-level goal)
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
<light2yellow>
ecraven: thank you, I forgot I can do this
<light2yellow>
jackdaniel: no high-level goal, just reading about macros and wondering what would be a substitute in normal expressions not prefixed by backquote, since I feel like splicing might be a useful thing
Ukari has quit [Ping timeout: 256 seconds]
python476 has quit [Ping timeout: 240 seconds]
<ecraven>
light2yellow: it's very instructive, especially since CL has macroexpand-1. unfortunately, most Schemes miss that one :-/
_paul0 has quit [Read error: Connection reset by peer]
<jackdaniel>
can someone try to load serapeum on the newest ql release? I have an error: `The function SERAPEUM::KEY is undefined.'
Ukari has quit [Ping timeout: 240 seconds]
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
josh_ has quit [Ping timeout: 240 seconds]
makomo has quit [Quit: WeeChat 2.0.1]
<Xach>
jackdaniel: i was able to load it no problem.
<jackdaniel>
thanks
<Xach>
using sbcl 1.3.11 on amd64
<Xach>
latest quicklisp dist
<jackdaniel>
then it is probably some mess on my system
<Xach>
no local-projects
<jackdaniel>
(sbcl 1.4.0 amd64, plenty of local-projects :)
<Xach>
they're up to 1.4.0 now? wow!!
<Xach>
those sbclians!
<jackdaniel>
I think that 1.4.x is a thing now (not sure if x=4 or 5)
orivej has quit [Ping timeout: 240 seconds]
brendyn has quit [Ping timeout: 248 seconds]
sauvin has quit [Ping timeout: 248 seconds]
* Xach
upgrades the server
makomo has joined #lisp
<jackdaniel>
same problem on ecl. I'll try on a separate user account later (without polluted asdf's registry)
orivej has joined #lisp
<jackdaniel>
yup, it loaded fine on fresh env
<knobo>
sbcl 1.4.7 now :O
warweasle has joined #lisp
<knobo>
With enhancement: better handling of unknown keyword arguments, which I have been wating for a couple of years :)
<knobo>
I think... I have to try it out.
papachan has joined #lisp
deba5e12 has quit [Quit: WeeChat 1.9.1]
_cosmonaut_ has quit [Ping timeout: 265 seconds]
wigust has joined #lisp
Ven`` has joined #lisp
thinkpad has quit [Ping timeout: 240 seconds]
cage_ has joined #lisp
thinkpad has joined #lisp
Ukari has joined #lisp
<knobo>
yes :) compilation without warnings :)
<mfiano>
Xach: This is strange. Even if I touch package.lisp as to force a full recompile, I do not get an error. However if I quickload with :verbose t, warnings become errors.
<mfiano>
So this is why I haven't caught what you have...and I'm unsure why this is occuring
<Xach>
mfiano: it is partly because quicklisp muffles warnings
matijja has quit [Ping timeout: 240 seconds]
<Xach>
mfiano: the best way to catch is to use :verbose t all the time or set *quicklisp-verbose*
<mfiano>
I've never had this issue before. Usually warnings stay as warnings
<jackdaniel>
I'm puzzled, I've cleaned cache, removed local-projects and common-lisp/ and I still have this weird issue
pierpal has quit [Ping timeout: 240 seconds]
<jackdaniel>
I've even removed quicklisp (and reinstalled it)
<Xach>
mfiano: when you ql:quickload something, by default, you don't see cl:warnings. if you asdf:load or use quickload verbose, you do.
<mfiano>
I understand that
<Xach>
ok
<mfiano>
That has always been the case
<Xach>
I don't think this is good but it is the way it is
<Xach>
mfiano: which is the part that has never happened before?
<mfiano>
Xach: The _error_ only occurs with :verbose t, and log only shows the _warning_.
<Xach>
asdf considers a warning during building an error on sbcl
<Xach>
there would be no "ERROR:" string in the logs
<mfiano>
Well that explains it. I don't remember this before :)
<Xach>
From my perspective, I wish there was a really easy way to say "build verbosely and don't catch warnings when building local things but build quietly and catch warnings when building quicklisp-provided things"
<Xach>
I have had no luck puzzling that one out
<Xach>
mfiano: i hope a fix is in the works for gamebox math?
<mfiano>
Xach: already pushed
<mfiano>
(Hopefully)
<Xach>
looks good to me, thanks
_cosmonaut_ has joined #lisp
* Xach
preps for liftoff
orivej has quit [Ping timeout: 276 seconds]
nowhere_man has quit [Remote host closed the connection]
_cosmonaut_ has quit [Read error: Connection reset by peer]
comborico1611 has joined #lisp
_cosmonaut_ has joined #lisp
<jasom>
drmeister: one of my first mentors taught me that communicating via queues is hard to mess up. Being hard to mess up is worth its weight in gold when it comes to concurrency
<jasom>
lparallel's channels are less general-purpose than a queue, but if they do what you need they are even easier.
<jasom>
lparallel even has a parallel map which may be handy
_cosmonaut_ has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
heisig has quit [Quit: Leaving]
yoel has quit [Remote host closed the connection]
LiamH has joined #lisp
larme1 has quit [Quit: WeeChat 1.9.1]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
<phoe>
"enhancement: namestrings can now be computed for certain pathnames that previously did not have namestrings because of #\. characters in their name and/or type components. "
<phoe>
I remember discussing this one on #lisp some time ago
* scymtym_
is always watching
<Petit_Dejeuner>
commuicating with queues has been easy in my experience as well
yoel has joined #lisp
<Petit_Dejeuner>
producers put to queue, consumers get form queue
orivej has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
al-damiri has joined #lisp
<jackdaniel>
creepy ;)
<jackdaniel>
drmeister: additional +: lparallel works on top of bt
<jackdaniel>
so you won't have to port it for clasp
Cymew has joined #lisp
jealousmonk has quit [Ping timeout: 268 seconds]
Cymew has quit [Ping timeout: 256 seconds]
johnvonneumann_ has quit [Remote host closed the connection]
<Xach>
sorry to be dense - can't really connect the dots there
<Xof>
I'm thinking aloud
<Xach>
I was thinking about doing something with *compile-file-truename* and if it's in the quicklisp path structure but I don't remember where I landed on that.
cage_ has quit [Remote host closed the connection]
<Petit_Dejeuner>
Is there an easy way to determine the endianess of the machine? All I found in uiop was some stuff for reading little endian bytes.
<Xof>
the way I'm thinking aloud about is finding the current operation / component and using that
<Xach>
Petit_Dejeuner: I don't know offhand, but I'm curious - what would you do with that info?
<Xof>
*systems-being-operated* unfortunately does not have the property we would like -- it doesn't tell us the innermost system
v0|d has quit [Remote host closed the connection]
<Xof>
and it's not clear to me whether you as quicklisp author are allowed to write methods on asdf:operate
<Petit_Dejeuner>
It's basically printf/scanf for binary formats.
<Xach>
Petit_Dejeuner: ah. so if you were to support "native" byte order
Kundry_Wag has joined #lisp
<Petit_Dejeuner>
Yeah.
<Petit_Dejeuner>
I wanted to do something like cl-ppcre where there was a sexpr and text notation, so I want the text notation to be as python comaptible as possible.
<Xof>
(if you are, you could write an around method that binds a special to the component being operated on, and test for that being in quicklisp's path)
pmetzger has joined #lisp
<Petit_Dejeuner>
Even though I don't see the point of a "native" byte order and figure people could determine that on their own. :/
pmetzger has left #lisp [#lisp]
<Xach>
Petit_Dejeuner: you could spawn python, pack in "native" order, and check the bytes you get back :)
scymtym__ has joined #lisp
sjl has joined #lisp
<Petit_Dejeuner>
lol, might as well just write a python script and have my library call it at that point
<Petit_Dejeuner>
If I was going to go down that route, I'd probably use C anyway.
<Petit_Dejeuner>
(Documentation says that's what Python does anyway.)
yoel has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 264 seconds]
Ven`` has joined #lisp
scymtym_ has quit [Ping timeout: 255 seconds]
varjagg has joined #lisp
puchacz has joined #lisp
<puchacz>
hi, what's the library for quoting text to be embedded into XML pls?
<puchacz>
I understand there are 2 levels of quoting, either preserving whitespace (rare) or not preserving whitespace (common)
<puchacz>
but things like > etc have to be quoted like in HTML
<puchacz>
not sure if text into attributes needs to be quoted in the same way as text sitting in text nodes
_cosmonaut_ has joined #lisp
asarch has joined #lisp
<mfiano>
Now that Lisp Game Jam 2018 is over, everyone can show a little support and vote for their favorites for the next 3 days before the results are public: https://itch.io/jam/lisp-game-jam-2018/entries
EvW has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
nika has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cpc26_ has joined #lisp
light2yellow has quit [Quit: light2yellow]
cpc26 has quit [Ping timeout: 255 seconds]
dilated_dinosaur has quit [Ping timeout: 256 seconds]
hhdave has quit [Ping timeout: 265 seconds]
sauvin has joined #lisp
himmAllRight has quit [Quit: WeeChat 2.0.1]
sauvin_ has joined #lisp
surya has joined #lisp
sauvin has quit [Ping timeout: 264 seconds]
Ukari has quit [Remote host closed the connection]
cezary has joined #lisp
jlarocco has quit [Ping timeout: 240 seconds]
xaxaac has joined #lisp
<jasom>
puchacz: all XML serialization libraries should be able to do that.
<jasom>
puchacz: I'm not aware of a stand-alone library for quoting though.
Ven`` has joined #lisp
comborico1611 has quit [Quit: comborico1611]
dilated_dinosaur has joined #lisp
jealousmonk has joined #lisp
<Xach>
hey, a new quicklisp this day
<phoe>
woooo
<puchacz>
jasom - ok, I will check, tks
Hello_ has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Josh_2 has joined #lisp
damke has joined #lisp
<Xach>
phoe: the :documentation value in a system file is not evaluated
<Xach>
wait, maybe it is. i will test.
<Xach>
ok, my mistake.
<Xach>
(also, it is :description)
<phoe>
Xach: oh woop, which system do you mean?
<Xach>
external-symbol-not-found has (format nil "...") for the :description.
<phoe>
Xach: it doesn't need to be evaluated
<phoe>
I have #. in there
<phoe>
so what ASDF sees is a plain old string
damke_ has quit [Ping timeout: 264 seconds]
SenasOzys has quit [Remote host closed the connection]
<Xach>
Oh, ok, sorry. Doubly my mistake.
<Xach>
I have some software that reads defsystem forms without evaluating anything.
<Xach>
It overrides sharp-dot.
<Xach>
And it recognizes some of the common ways to slurp documentation in, but not format nil.
<phoe>
Yep, I see.
SenasOzys has joined #lisp
mflem has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
m00natic has quit [Remote host closed the connection]
surya has quit [Read error: Connection reset by peer]
terpri has quit [Ping timeout: 260 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orestarod has quit [Ping timeout: 256 seconds]
yoel has joined #lisp
yoel has quit [Ping timeout: 240 seconds]
slyrus1 has joined #lisp
scymtym__ has quit [Ping timeout: 240 seconds]
slyrus1 has quit [Quit: slyrus1]
LiamH has quit [Quit: Leaving.]
jealousmonk has quit [Quit: Leaving]
scymtym has joined #lisp
slyrus1 has joined #lisp
larme has joined #lisp
mathrick has quit [Ping timeout: 240 seconds]
<ym>
Are there attempts to crossbreed SBCL with Linux so that first process started by kernel would be SBCL?
<ym>
(yes, yet another LispOS question)
<dlowe>
it's trivially possible.
<dlowe>
but then what?
<dlowe>
at least when you use an emacs init, you can edit files
<aeth>
ym: That is what I call the top-down LispOS approach
<aeth>
as opposed to a bottom up one like Mezzano
<ym>
CL can into files.
Ven`` has joined #lisp
<aeth>
I'm not aware of any top-down approach because to be practical, as dlowe said, you'd have to start further up in the "top" part
<aeth>
and then there's... McCLIM and not much else
<ym>
Why McCLIM?
xrash has quit [Ping timeout: 240 seconds]
<ym>
I prefer to use DRM/KMS directly.
<ym>
It's pretty simple.
SenasOzys has quit [Ping timeout: 240 seconds]
megalography has quit [Ping timeout: 240 seconds]
<White_Flame>
ym: but that would just get you a raw framebuffer. McCLIM would be what draws on top of that
<jackdaniel>
I for instance use McCLIM, because people would shame me if I wouldn't ;-)
<jackdaniel>
(answering "why" ;-)
SenasOzys has joined #lisp
<jackdaniel>
ym: but to provide example of some adventages, you may watch this video (first 12m: https://youtu.be/RBOrllTA-yc)
<ym>
White_Flame, all I want is a raw framebuffer (well, with SIMD-optimized rendering, but SBCL has SIMD support, so that's no problem).
<White_Flame>
that's not much of a "LispOS" though
yoel has joined #lisp
<White_Flame>
as an OS would presumably allow sharing of resources, including the screen
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ym>
Sharing screen?
<White_Flame>
um, yeah, like windows or at the very least swapping between programs' screens
random-nick has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
LiamH has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
SaganMan is now known as e^i
<ym>
IIRC there is X server implementation in CL, but I don't think about it yet. All I want is, ghm, SBCL minimalistic environment with DRM graphics output linux /dev/input as input etc. For my personal nearly-embedded needs.
<ym>
jackdaniel, nice video.
e^i is now known as SaganMan
enzuru has joined #lisp
sauvin_ has quit [Remote host closed the connection]
<White_Flame>
what's ghm?
<edgar-rft>
God Help Me
Ven`` has joined #lisp
<White_Flame>
ah, so basically the SBCL version of a Commodore 64 :)
<jackdaniel>
thank you
<edgar-rft>
whenever there's something unclear, ask me :-)
<ym>
ghm is my version of a coughing sound
<dlowe>
(loop (write-line "I AM AWESOME"))
pierpal has joined #lisp
yoel has quit [Remote host closed the connection]
foojin has joined #lisp
_cosmonaut_ has quit [Ping timeout: 240 seconds]
MichaelRaskin has joined #lisp
python476 has quit [Ping timeout: 240 seconds]
EvW1 has joined #lisp
SlowJimmy has joined #lisp
<TMA>
is there a SOAP web service client in quicklisp besides hu.dwim.utils/soap? (or more documentation than http://quickdocs.org/hu.dwim.util/api, which is sparse and does not cover the soap/XML part at all)
ebrasca has quit [Remote host closed the connection]
pierpal has quit [Ping timeout: 268 seconds]
nika has quit [Quit: Leaving...]
pierpal has joined #lisp
pierpal has quit [Client Quit]
dcluna has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
yoel has joined #lisp
random-nick has joined #lisp
shrdlu68 has joined #lisp
<yoel>
Petit_Dejeuner: If u r still looking for Python's struct alternative, take a look at userial
Cymew has joined #lisp
rumbler31 has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
pierpal has joined #lisp
sz0 has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
terpri has joined #lisp
pjb has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_W_ has joined #lisp
SuperJen has joined #lisp
Jen has quit [Ping timeout: 264 seconds]
energizer has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
zachk has joined #lisp
zachk has joined #lisp
zachk has quit [Changing host]
comborico1611 has joined #lisp
<Petit_Dejeuner>
yoel: thx
pierpal has quit [Ping timeout: 268 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Kundry_W_ has quit [Remote host closed the connection]
Mutex7 has joined #lisp
pierpa has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<thorondor[m]>
hello. I've noticed that ECL is quite slower than SBCL/CCL. Why is it? Is it just that the C compilation in ECL cannot compete with the assembler of SBCL/CCL. Or there are also other factors?
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<Xach>
thorondor[m]: i think there have been many many more person-years of effort put into making sbcl compile to efficient code than ecl.
<Xach>
I would be somewhat surprised if there was an inherent problem with the compile-to-c approach that effort could not overcome
<thorondor[m]>
aha
megalography has joined #lisp
<thorondor[m]>
ECL approach is very attractive as it make it very easily portable, but I noticed some slowness
yoel_ has joined #lisp
shka has quit [Quit: Konversation terminated!]
yoel_ has quit [Client Quit]
megalography has quit [Ping timeout: 264 seconds]
yoel has quit [Remote host closed the connection]
yoel has joined #lisp
damke_ has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
yoel has quit [Ping timeout: 248 seconds]
damke has quit [Ping timeout: 264 seconds]
<p_l>
I strongly suspect it might depend on whether "portable" C is target or not
<p_l>
my personal goals involving ECL require the portable part :)
lonjil has joined #lisp
<p_l>
so I hope it keeps being available
shka has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Karl_Dscc has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
Kundry_W_ has joined #lisp
Kundry_W_ has quit [Read error: Connection reset by peer]
Kundry_W_ has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
<jackdaniel>
according to the comparison I've read from '90 KCL (which is ancestor of ECL) was comparable in speed with back-in-a-day CMU CL
<pierpa>
for the sake of comparison, you may check other lisp-like languages which compile through C. One such language which produces fast code is Biglo, for example.
<jackdaniel>
but KCL family was most of its lineage a few men effort, so I think that what Xach said makes sense: most of it boils down to man-hours
Kundry_W_ has quit [Remote host closed the connection]
<jackdaniel>
compiling to C has some drawbacks, but also has some adventages. one of the adventages is that gcc also performs certain optimizations (not much though - abstraction prevents some of possibilities)
<jackdaniel>
clasp achives a similar thing by compiling with LLVM (which also optimizes things)
Kundry_Wag has joined #lisp
<jackdaniel>
of course both (ECL and Clasp) have their own compilers with optimizations of their own
orivej has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<thorondor[m]>
also, I find dealing with C easier than assembler
Kundry_Wag has joined #lisp
jmercouris has quit [Remote host closed the connection]
<jackdaniel>
of course this is archeology, but very intresting and useful if you plan to dig in ECL's innards
orivej has quit [Ping timeout: 260 seconds]
_whitelogger has joined #lisp
<thorondor[m]>
btw, after updating ECL from gitlab, I cannot see debugging locals in stack frames from SLIME. although I'm not 100% it was because of the ECL upgrade
orivej has joined #lisp
<jackdaniel>
that's not enough details for me. if you decide to report an issue, please include comparison between two builds (last release and develop build) and description what has changed/ how to reproduce that easily
<jackdaniel>
we had some changes with stacks lately, so there might be a regression
pierpal has quit [Ping timeout: 260 seconds]
<thorondor[m]>
ok, just mentioning it in case you noticed the same or somthing
damke has joined #lisp
<jackdaniel>
sure
<jackdaniel>
thanks
damke_ has quit [Ping timeout: 264 seconds]
asarch has quit [Quit: Leaving]
Quetzal2 has quit [Read error: Connection reset by peer]
comborico1611 has quit [Quit: Konversation terminated!]
orivej has quit [Ping timeout: 265 seconds]
khisanth__ has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
milanj_ has joined #lisp
angavrilov has quit [Remote host closed the connection]
pjb has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
python47` has joined #lisp
milanj__ has quit [Ping timeout: 248 seconds]
hhdave has joined #lisp
Kundry_Wag has joined #lisp
hhdave_ has joined #lisp
khisanth__ has joined #lisp
varjagg has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<jmercouris>
options for hosting a DNS server? anyone ever done one with Lisp?
<fe[nl]ix>
jmercouris: I like Gandi
hhdave has quit [Ping timeout: 248 seconds]
hhdave_ is now known as hhdave
<jmercouris>
fe[nl]ix: sorry for not clarifying, I didn't mean a hosting provider (I too use Gandi, great company), I mean for software to serve DNS
<edgar-rft>
I've heard nil serves great as a Do-Not-Serve server
<jmercouris>
edgar-rft: a Link? I don't think it'll be easy to google "nil"
<jmercouris>
or are you making a joke?
python47` has quit [Read error: Connection reset by peer]
<edgar-rft>
nil serves nothing, so it's a great Do-Not-Serve server
<edgar-rft>
I only wanted to motivate you :-)
<foom>
Gandi does a great job at serving DNS for you, so you don't need your own server.
<foom>
(Sorry, I have no idea about your actual question of a Lisp DNS server)
<fe[nl]ix>
jmercouris: DNS is so complicated nowadays that you definitely don't want your own server
Bike has quit [Ping timeout: 260 seconds]
<drmeister>
What do folks recommend in the following situation - I've got a grammar that I'm putting together that looks like the following:
<drmeister>
A bunch of lists of symbols. I've got this special symbol 'CYCLE and I should prefix it with the package that it's defined within.
<drmeister>
But I forget to do that sometimes and then it's not recognized properly. I was thinking of recognizing any symbol with (string-equal (string sym) "CYCLE")) - is that a bad idea?
<drmeister>
I could use the :cycle keyword symbol instead - but everything else is keyword symbols.
<drmeister>
I'm developing a grammar to describe how to build molecules from parts.
<drmeister>
It goes molecule-part connection molecule-part connection molecule-part ...
<drmeister>
A molecule-part can be a symbol or a list with the form (name :label label) or ((name1 name2 name3 ...) :label label)
<drmeister>
:default is a default connection
<drmeister>
It's a bit more involved - but you get the picture.
<drmeister>
Oh - the (:cycle name) thing is to close a ring.
<jmercouris>
fe[nl]ix: it's complex, but it is the easiest way for me to do adblocking, I might just append to the hosts file for now, pointing to 0.0.0.0
<fe[nl]ix>
on what OS ?
<jmercouris>
Linux/OSX
<fe[nl]ix>
you can use dnsmasq
<jmercouris>
that's a good idea
<drmeister>
Meh - scr3w it - I'll use :cycle
<jmercouris>
didn't know it worked on OSX
<jmercouris>
thanks for the tip
iqubic has joined #lisp
TCZ has joined #lisp
<thorondor[m]>
drmeister: I think using (string-equal (string sym) "CYCLE")) could be OK. I think that same technique is used in LOOP macro for example
makomo has quit [Ping timeout: 276 seconds]
shka has quit [Ping timeout: 240 seconds]
<drmeister>
thorondor[m]: Thank you. Is that how the LOOP macro handles all of its loop keywords?
<drmeister>
Rhetorical question - you just said that.
<thorondor[m]>
yes, I think so
mercourisj has joined #lisp
mercourisj has quit [Remote host closed the connection]
<rme>
I think it uses symbol-name, but same idea, yeah.
mercourisj has joined #lisp
<aeth>
jackdaniel, ym: What I'm personally going to be doing for GUI "soon" is writing on top of cl-sdl2 and cl-opengl (although I'll probably replace cl-sdl2 with my own SDL bindings)
<drmeister>
Yes - looking at the LOOP source code - that is what it does.
margeas has quit [Quit: Konversation terminated!]
puchacz has quit [Quit: Konversation terminated!]
<drmeister>
If it's good enough for LOOP - it's good enough for me - thank you.
jmercouris has quit [Ping timeout: 264 seconds]
yoel has quit [Ping timeout: 240 seconds]
comborico1611 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<Petit_Dejeuner>
aeth: what's wrong with the current bindings?
<aeth>
Petit_Dejeuner: With cl-opengl, they're just the bindings, and you can just use %gl if you want to directly use the low-level bindings.
<aeth>
Petit_Dejeuner: cl-sdl2 adds a *ton* of undocumented, complicated stuff on top.
<aeth>
Plus, the author left the Lisp community so now afaik no one understands how the whole thing works.
<Petit_Dejeuner>
he left?
<aeth>
Yeah, afaik it's basically in maintenance mode now, even though the bindings are apparently incomplete.
<aeth>
I've piece-by-piece rewritten almost all of my usage of cl-sdl2 outside of the init part to use as low level as the library permits (even if I have to use :: private stuff), so it shouldn't be *that* hard for me to switch to fresh bindings, especially if I replace the init stuff first.
Bicyclidine is now known as Bike
<Petit_Dejeuner>
Seems like a pain to have to use raw FFI bindings. :/
<aeth>
It's actually easier because at least the C side is documented.
<Petit_Dejeuner>
Yeah, that's true.
<aeth>
You replace like 1 undocumented line or macro with 5 documented CFFI lines
<Petit_Dejeuner>
At least cl-sdl2 has doc strings. I know some people like to set them away from the definition of the function, but that just makes it a pain tor ead imho.
SenasOzys has quit [Read error: Connection reset by peer]
<aeth>
The problem is that cl-sdl2 uses a lot of large, incredibly fancy, undocumented macros, both directly in the package and indirectly through stuff like autowrap
<aeth>
It has taken probably a total of 2 months of my time over the years to know as much about it as I do know
<aeth>
I don't think I've seen more sophisticated macros in library code.
<pierpa>
thorondor[m]: STRING-EQUAL works on symbols. No need to convert explicitly.
<aeth>
When it works, it works. When you want to do something not directly supported by that macro... well... that takes some time.
<Petit_Dejeuner>
That looks pretty rough.
sjl has quit [Quit: WeeChat 2.0.1]
<Bike>
what a scary looking function
<drmeister>
Yes - I noticed that in the LOOP code they use (STRING= frob loop-keyword)
<aeth>
I have never seen a macro like c-let before. It essentially creates a pseudo-macro, pseudo-function call. So let's say you have "event" in with-sdl-event. That doesn't actually exist. It's rewritten in the code-rewriting in c-let.
TCZ has quit [Quit: Leaving]
<aeth>
So when you see (event ...) that call doesn't exist, it's rewritten by c-let
<Bike>
well macrolet isn't too surprising
<drmeister>
Bike: I got grammar like this to work: (:= *olig3* (design:make-oligomer *parts* '((:lego3 :label :first) :default :lego3 :default :lego3 :default (cycle :first))))
<random-nick>
maybe-make-macro is a really funny name
<aeth>
Well it's a macrolet and a symbol-macrolet in two mutually-recursive Lisp functions. I'm not sure I've seen anything more advanced than that.
<Petit_Dejeuner>
"News of my death have been greatly exagerated." -Lisp
<Petit_Dejeuner>
-Also, Ada
<aeth>
What's cool about #'random is that #'random on fixnums in SBCL is apparently non-consing and quite efficient.
<aeth>
So feel free to use #'random literally everywhere, all of the time.
<Petit_Dejeuner>
tbh, I'd be surprised if #'random WAS consing
Kundry_Wag has joined #lisp
<aeth>
It could easily generate garbage if you used arrays
<mercourisj>
theoretically lisp is one of the few programming languaes that could generate truly random applications
<mercourisj>
you could use random to random select symbols and combine them until you have a full program
<aeth>
well, not portably
random-nick has quit [Read error: Connection reset by peer]
<mercourisj>
aeth: what do you mean?
<aeth>
If you wanted random #'random, afaik, you'd have to use an implementation-specific way to provide a seed to the random state.
<mercourisj>
oh, I see
<mercourisj>
I just mean in the sense that one can use macros to generate random code on the fly
<Petit_Dejeuner>
I always thought it would be fun to make a library add advertisement blurbs and links to all the public identifiers at compile time.
<mercourisj>
rather than having some random condition within another language
<aeth>
e.g. an OS call to get a better random, once, and use that to seed #'random
sjl has joined #lisp
<aeth>
although for all I know that's what SBCL does internally without a provided seed
<Bike>
(make-random-state t) is the "seed from something" call
<aeth>
What's the current way to get randomness on Linux? The getrandom() system call?
<aeth>
There are like 8 ways
Kundry_Wag has quit [Ping timeout: 264 seconds]
<Petit_Dejeuner>
Which is the RIGHT way?
<scymtym>
aeth: no, SBCL initializes the random state to a fixed constant. without the call Bike mentioned, subsequent (non-threaded) runs will produce identical sequences of "random" values
sucks has joined #lisp
sucks has quit [Max SendQ exceeded]
<mercourisj>
(defun random () 10)
bjorkintosh has quit [Remote host closed the connection]
<aeth>
scymtym: Yes, but there are two ways to actually set up a random state, including on SBCL, afaik. The portable way and the provide-a-seed way
bjorkintosh has joined #lisp
alandipert has quit [Ping timeout: 264 seconds]
alandipert has joined #lisp
markong has joined #lisp
<scymtym>
aeth: that is true but none of those happen automatically at startup
<aeth>
scymtym: Yes, I was just wondering how SBCL gets a random state in make-random-state because obviously if it used #'random it would cycle through the same random states!
Tristam has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
Bike has quit [Ping timeout: 264 seconds]
hhdave has joined #lisp
<scymtym>
aeth: sure. on linux, it reads from /dev/urandom and uses a weaker fallback based on time and PID if that fails
Bike has joined #lisp
Kundry_Wag has joined #lisp
<aeth>
scymtym: I don't think urandom is recommended anymore
megalography has joined #lisp
<mercourisj>
I believe the accepted way of getting a random seed is by downloading random++ from npm
<aeth>
I think getrandom() is the new recommend way in Linux
<mercourisj>
the reason why it will always be something new is because you'll be fulfilling the dependency via NPM, and who knows what it will be
* scymtym
loves how the urandom(4) man page claims that getrandom(2) is the safer alternative and then 50% of that man page is a super-complicated section called "Interruption by a signal handler"
<rme>
the /dev/urandom way is nice because it works on a lot of systems (at least linux/freebsd/osx/solaris-ish)
Kundry_Wag has quit [Ping timeout: 260 seconds]
hhdave has quit [Quit: hhdave]
Rawriful has quit [Quit: WeeChat 1.4]
<aeth>
Well I can understand why switching to getrandom() right way was probably not a good idea because it was introduced fairly recently. The manpage says kernel 3.17
<aeth>
kernel.org even shows 2 longterm kernels still supported that have a lower version number!
<aeth>
s/right way/right away/
Tristam has joined #lisp
Josh_2 has quit [Ping timeout: 240 seconds]
xrash has joined #lisp
fsmunoz has joined #lisp
lnostdal has quit [Ping timeout: 240 seconds]
lnostdal has joined #lisp
ealfonso has joined #lisp
<ealfonso>
why is hunchentoot insisnting on using html error templates when I set hunchentoot:acceptor-error-template-directory to nil?
Cymew has joined #lisp
mercourisj has quit [Remote host closed the connection]
<ealfonso>
s/insisnting/insisting
<pierpa>
there was no doubt about what you meant :)
<ealfonso>
s/insisnting/insististing
<pierpa>
lol. Still no doubt
<aeth>
instantiating
Cymew has quit [Ping timeout: 265 seconds]
<ealfonso>
"If an ERROR-TEMPLATE-DIRECTORY is set in the current acceptor and the directory contains a file corresponding to HTTP-STATUS-CODE named <code>.html, that file is sent to the client after variable substitution"
rumbler31 has joined #lisp
zooey has quit [Ping timeout: 255 seconds]
Pixel_Outlaw has joined #lisp
wheelsucker has quit [Ping timeout: 256 seconds]
lemoinem has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
lemoinem has joined #lisp
SuperJen has quit [Remote host closed the connection]