<fiddlerwoaroof>
didi: EVAL-WHEN sounds a bit scary, but there's only really one form that you'll find yourself using in most circumstances: (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)...)
<fiddlerwoaroof>
serapeum provides EVAL-ALWAYS that shortens this pattern
<cl-arthur>
pjb: cheers, several interesting ideas there! Will comb through more carefully tomorrow :)
lonjil has quit [Quit: No Ping reply in 180 seconds.]
lonjil2 has joined #lisp
igemnace has joined #lisp
ThomasLewis[m] has quit [Ping timeout: 252 seconds]
Bike has joined #lisp
parjanya has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<Josh_2>
how can I go from a list like (list *header* *index-body*) to just *header* *index-body* so I can pass the arguments of an unknown length list to a function like append
<Josh_2>
Pretty sure there has gotta be an easier way to do this
akater has quit [Remote host closed the connection]
<Josh_2>
I did it
<Josh_2>
I was being an absolute mongo...
akater has joined #lisp
<Josh_2>
Yay working now :D
trocado has quit [Ping timeout: 255 seconds]
Oladon has joined #lisp
CCDelivery has joined #lisp
comborico1611 has joined #lisp
<comborico1611>
Does LOAD allow a form calling a function before that function is defined in a compiled file?
<comborico1611>
(Before meaning sequence of file.)
<comborico1611>
All of this taking place in a REPL.
torbo has joined #lisp
<jasom>
comborico1611: define "calling". You can define functions that call functions that have not been defined. Actually calling the function as a toplevel form is unlikely to do what you want.
<Josh_2>
How on earth do I join parts of websites together with cl-who...
<jasom>
Josh_2: example?
<Josh_2>
one sec
<comborico1611>
jasom: (some-function 'whatever) [then on next line] (defun some-function ....)
<jasom>
comborico1611: yeah, that's not a good idea; I don't know off the top of my head if it's allowed (assuming some-function is already defined before you call LOAD)
<Bike>
if some-function isn't defined it's an error, of course
<Josh_2>
jasom: https://plaster.tymoon.eu/view/1232#1232 so I have *index-body* and *navigation* both evaluate to strings but I want to stick the value of *navigation* into the macrobody and get it to evaluate Q_Q
<Josh_2>
I can always just ` the code I suppose
<comborico1611>
So the layout of a source file must always be logical sequential?
<Josh_2>
but this is kinda annoying
<Bike>
comborico1611: LOAD literally just evaluates one form at a time
<Bike>
like entering them in the repl one after another
<comborico1611>
Bike: Ahh! I see. Is there an alernative?
<Josh_2>
Hey that works
<Bike>
compile-file will result in a fasl file that's a little smarter
<Bike>
i think this particular case will still fail, though
<comborico1611>
Does COMPILE-FILE also "run" the code?
<Bike>
no, it compiles it
<Bike>
some forms may be evaluated at compile time to support that, like macro definitions, but most things aren't run
<Bike>
i'm not sure what you really want here - not having to worry about order makes sense if it's not a sequential list of things to do, but if it's not a list of things to do putting a (some-function 'whatever) call at top level is nonsensical
<comborico1611>
If i use LOAD on a compiled file, it still evaluates forms sequentially?
<Bike>
mostly
<Josh_2>
and now I'm using eval again Q_Q
<comborico1611>
This cart-before-the-horse ordering is mainly to aid in reading code by zooming out of details.
<Josh_2>
yay
<Bike>
i mean, and i just want to reiterate this, (defun foo () (some-function 'foo)) (defun some-function ...) is fine
<Bike>
it's having the call at top level that's a problem
<jasom>
Josh_2: print
<jasom>
Josh_2: or (str *navigation*) in this case
dddddd has quit [Remote host closed the connection]
<comborico1611>
Bike: I see. This is helpful. Thanks!
lumm has quit [Quit: lumm]
Essadon has quit [Quit: Qutting]
<Josh_2>
jasom: str?
<jasom>
cl-who:str puts a string directly into the output without escaping. cl-who:esc does the same, but escaping things (so e.g. < becomes <
robdog has joined #lisp
<Josh_2>
jasom: #<UNDEFINED-FUNCTION STR
<Josh_2>
(cl-who:str
<jasom>
Josh_2: cl-who:str is special-cased inside the with-html-output form
<Josh_2>
I was just use defparams while I messed around and got a grip with cl-who but it appears to have been an hinderance
comborico1611 has quit [Quit: Konnection terminated!]
<jasom>
you can actually completely omit the optional outstream argument if you just want to always use *html-outstream* but I find it easier to pass a stream as a parameter than to bind a special when I'm doing quick checks of what functions will return at the repl.
<jasom>
e.g. you could call (navigation *standard-output*) at the repl to print the output of just navigation.
<Josh_2>
I make the output stream then use with-output-to-stream?
<jasom>
I was suggesting with-output-to-string not with-output-to-stream
<Josh_2>
Yes sorry
wanz has quit [Quit: wanz]
<jasom>
e.g. (with-output-to-string (*html-output*) (index-page))
wanz has joined #lisp
<jasom>
that will return a string
wanz has quit [Client Quit]
<jasom>
or just (let ((*html-output*)) (send-headers) (index-page))
<jasom>
though IIRC that might be a binary stream, so you might have to make a bivalent stream on top of that
<jasom>
minor correction: (let ((*html-output* (send-headers))) (index-page))
wanz has joined #lisp
<jasom>
(send-headers) on hunchentoot returns a binary stream that you can write the response to
Jesin has quit [Quit: Leaving]
<Josh_2>
hmmm
<Josh_2>
good idea
<Josh_2>
Its a chunked io stream
robdog has joined #lisp
<Josh_2>
huh, for some reason half my html is duplicating went sent to the stream
<Josh_2>
or in the stream I'm not sure
<Josh_2>
O
<Josh_2>
Fixed it
Jesin has joined #lisp
robdog has quit [Ping timeout: 255 seconds]
edgar-rft has joined #lisp
karlosz has joined #lisp
robdog has joined #lisp
<Josh_2>
jasom: thanks for all the help :)
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
robdog has quit [Ping timeout: 240 seconds]
milanj has quit [Quit: This computer has gone to sleep]
zmt00 has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
Oladon has joined #lisp
quazimodo has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
dale has quit [Quit: dale]
wanz has quit [Quit: wanz]
wanz has joined #lisp
karlosz has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
gravicappa has joined #lisp
robdog has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
quazimodo has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 240 seconds]
beach has joined #lisp
<beach>
Good morning everyone!
robdog has joined #lisp
aeth has quit [Ping timeout: 244 seconds]
robdog has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
<moldybits>
morning
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
brandonz has joined #lisp
exit70 has quit [Quit: Connection closed for inactivity]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
abhixec has joined #lisp
<abhixec>
join #python
robdog has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
abhixec: type `/quit` into your IRC client
marvin2 has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
vilivulpine has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
CCDelivery has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
robdog has joined #lisp
marvin2 has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
Inline has quit [Quit: Leaving]
dale has joined #lisp
robdog has joined #lisp
ltriant has quit [Quit: leaving]
robdog has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
robdog has joined #lisp
groovy2shoes has quit [Quit: moritura te salutat]
robdog has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
mrcom_ has joined #lisp
jprajzne has quit [Quit: jprajzne]
mrcom has quit [Ping timeout: 245 seconds]
rumbler31 has quit [Remote host closed the connection]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
troydm has joined #lisp
robdog has joined #lisp
nalkri has joined #lisp
dale has quit [Quit: dale]
robdog has quit [Ping timeout: 240 seconds]
xkapastel has joined #lisp
zmt00 has quit [Quit: Leaving]
robdog has joined #lisp
zmt00 has joined #lisp
frodef has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
robdog has joined #lisp
jprajzne has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
vlatkoB has joined #lisp
makomo has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
milanj has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
JohnMS_WORK has joined #lisp
milivoj has joined #lisp
amerlyq has joined #lisp
shka_ has joined #lisp
torbo has quit [Remote host closed the connection]
robdog has joined #lisp
shrdlu68 has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
milivoj has quit [Read error: Connection reset by peer]
milivoj has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
beach has left #lisp ["ERC Version 5.3 (IRC client for Emacs)"]
robdog has joined #lisp
varjag has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
dddddd has joined #lisp
rumbler31 has joined #lisp
wkmanire has joined #lisp
Necktwi has quit [Quit: leaving]
cross_ has quit [Quit: Lost terminal]
orivej has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
nanoz has joined #lisp
robdog has joined #lisp
sunwukong has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
karlosz has quit [Quit: karlosz]
scymtym has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<splittist>
morning
<no-defun-allowed>
Morning splittist
milivoj has quit [Quit: milivoj]
<varjag>
long shot, but is there any cl implementation that supports arm neon intrinsics?
robdog has joined #lisp
wanz has quit [Quit: wanz]
robdog has quit [Ping timeout: 240 seconds]
wkmanire has quit [Ping timeout: 245 seconds]
nanoz has quit [Read error: Connection reset by peer]
sunwukong has quit [Ping timeout: 245 seconds]
SlashLife has quit [Ping timeout: 258 seconds]
heisig has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
hhdave has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 250 seconds]
hhdave_ is now known as hhdave
cl-arthur has quit [Quit: Lost terminal]
glv has joined #lisp
sunwukong has joined #lisp
wanz has joined #lisp
<heisig>
What does #lisp think about having an extensible defclass macro? Or is there already such a thing?
<heisig>
The idea would be that the metaclass can decide what clauses are allowed and how they are handled.
<heisig>
For example, one could define default methods for (:metaclass structure-class) that expand the entire thing into a defstruct definition.
robdog has joined #lisp
dacoda has joined #lisp
gravicappa has quit [Ping timeout: 255 seconds]
robdog has quit [Ping timeout: 240 seconds]
wanz has quit [Quit: wanz]
q3d has joined #lisp
nanoz has joined #lisp
Ukari has quit [Ping timeout: 245 seconds]
Ukari has joined #lisp
robdog has joined #lisp
<shka_>
heisig: does not sound like a good idea
robdog has quit [Ping timeout: 240 seconds]
<shka_>
heisig: defclass is supposed to be simple syntax sugar around setf find-class
robdog has joined #lisp
robdog_ has joined #lisp
<heisig>
shka_: I know. But how do I pass additional arguments to my custom metaclass? By not using defclass?
easye has joined #lisp
easye has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 240 seconds]
<shka_>
heisig: do you mean make-instance that creates your class?
<heisig>
Yes. With make-instance, I have full flexibility.
<shka_>
ok, so you want to pass extra options to make instance called on your metaclass, right?
robdog_ has quit [Ping timeout: 264 seconds]
<shka_>
do i understand correctly?
<heisig>
Right.
<heisig>
... and I'd like to be able to define additional toplevel forms, too :)
<heisig>
For handling options like (:predicate NAME).
easye has joined #lisp
<heisig>
But I am not sure whether that is a sane thing to do. The spec doesn't allow it, so I guess there must be a reason.
<shka_>
well, i think that passing additional options in usual place in defclass may be portable enough
<shka_>
oh, wait
<shka_>
you can't plug into shared-initialize with structs
lumm has joined #lisp
* shka_
scratches his head
<shka_>
shka_: i think that bridging structs and standard-classes can be non trivial
<heisig>
Yes, it is a nightmare. But I think it is doable with not too many caveats.
<heisig>
If it gets me rid of the syntax of defstruct, I'm willing to pay the price :)
<shka_>
heisig: i think i have an idea
<heisig>
Yes?
<shka_>
since issue here is that you can't count on shared-initialize
<shka_>
maybe you can simply add your own initialize generic function and simply call it manually
<shka_>
with proper class, that is
<shka_>
or class name
<shka_>
how does it sound?
trocado has joined #lisp
<heisig>
shka_: I will think about it. Thank you for your input.
<shka_>
i am always happy to help
shrdlu68 has quit [Ping timeout: 240 seconds]
<jackdaniel>
heisig: do avoid controversy name it define-class
<jackdaniel>
and work from there
<jackdaniel>
(to have a common syntax for defclass and defstruct that is)
lavaflow has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
_whitelogger has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
orivej has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
<heisig>
jackdaniel: Yes, shadowing CL symbols is not a wise move. I will either call it define-class or defclass*.
cl-arthur has joined #lisp
techquila has quit [Ping timeout: 240 seconds]
m00natic has joined #lisp
robdog has quit [Ping timeout: 257 seconds]
rumbler31 has quit [Remote host closed the connection]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
wilfredh has joined #lisp
gareppa has joined #lisp
<akater>
Does SBCL do “translation to C” at any point to produce native code for ANSI CL? (I believe it's not but I'd like to make sure.)
gareppa has quit [Remote host closed the connection]
milanj has joined #lisp
<shka_>
akater: no
wanz has joined #lisp
orivej has joined #lisp
nalkri has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<TMA>
akater: ecl is doing that
robdog has joined #lisp
wanz has quit [Quit: wanz]
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
SlashLife has joined #lisp
lucasb has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
zooey has quit [Remote host closed the connection]
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
zooey has joined #lisp
Essadon has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<akater>
TMA shka_: I'm aware of basics when it comes to SBCL and ECL, I just happened to encounter someone spreading claims that Lisp is hopelessly dependent on C.
<akater>
As far as I understand, once you have something like SB-SYS:*LINKAGE-INFO* and corresponding infrastructure, and have your system bootstrapped, there is no need to rely on C at all.
q3d has quit [Ping timeout: 256 seconds]
<heisig>
akater: The SICL project has also made a lot of progress towards bootstrapping Common Lisp from Common Lisp. It does not contain a single line of C code.
robdog has joined #lisp
milivoj has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<shka_>
akater: hopelessly?
<shka_>
not really
<shka_>
akater: this sounds like some C fanatic text
<p_l>
akater: where did you find such a person?
<p_l>
they need schooling xD
<shka_>
p_l: you need to believe in some virgins in heaven to write in C :P
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 255 seconds]
q9929t has joined #lisp
rumbler31 has joined #lisp
aeth has joined #lisp
q9929t has quit [Remote host closed the connection]
cantstanya has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 255 seconds]
<p_l>
C can be fun
<p_l>
but there are limits
q9929t has joined #lisp
cantstanya has joined #lisp
robdog has joined #lisp
<varjag>
lisp predates c so can't depend on it too much
rozenglass has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<shka_>
well, the question was about sbcl
<jcowan>
There are very few language implementations that are completely independent of C, unless (e.g.) they compile I/O operations into system calls rather than libc function calls.
<jcowan>
Also, C with libgc is rather a nice language, although I've only used it once so far (I was modifying a buggy C program that had its own very limited gc).
<jackdaniel>
is that person making an argument, that CL is a crappy language because C is a crappy language? :-)
<jackdaniel>
[and because CL "depends" on C]
Bike has joined #lisp
nanozz has joined #lisp
<shka_>
everything depends on OS, essentially
<shka_>
java, lisp, .net you name it
nanoz has quit [Ping timeout: 250 seconds]
<varjag>
" spreading claims that Lisp is hopelessly dependent on C" (sic)
scymtym has quit [Ping timeout: 240 seconds]
nanozz is now known as nanoz
elderK has joined #lisp
<pjb>
being dependent on libc is not being dependent on C. libc can be implemented in any programming language. Including CL.
wanz has joined #lisp
scymtym has joined #lisp
<shka_>
good point
xkapastel has joined #lisp
robdog has joined #lisp
lumm has quit [Quit: lumm]
Achylles has joined #lisp
robdog_ has joined #lisp
<Posterdati>
hi
<shka_>
Posterdati: hi
charh has quit [Ping timeout: 268 seconds]
q9929t has quit [Ping timeout: 244 seconds]
robdog has quit [Ping timeout: 240 seconds]
charh has joined #lisp
milanj has quit [Read error: Connection reset by peer]
patlv has joined #lisp
robdog has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
ebrasca has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
<Posterdati>
please I need help with the minimization in gsll
<pjb>
Posterdati: but in C, the functions to minimize take a vector and a parameter (closure).
patlv has quit [Ping timeout: 240 seconds]
patlv has joined #lisp
patlv has quit [Client Quit]
Inline has joined #lisp
lumm has joined #lisp
lumm has left #lisp [#lisp]
rippa has joined #lisp
robdog has joined #lisp
lumm has joined #lisp
akr has joined #lisp
wanz has quit [Quit: wanz]
robdog has quit [Ping timeout: 252 seconds]
<jcowan>
pfdietz_: By "fat pointer" I was talking about a data structure of some sort containing a reference to a string (or any 1d array), an offset, and a length. Unless this data structure were known to the GC, there's no way it could reclaim inaccessible parts of the string.
akr has left #lisp ["WeeChat 2.4"]
shka_ has quit [Quit: WeeChat 1.9.1]
<Posterdati>
pjb: I implemented as you said
robdog has joined #lisp
frodef has quit [Ping timeout: 255 seconds]
dale_ has joined #lisp
dale_ is now known as dale
flamebeard has quit []
abhixec has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
trocado has quit [Ping timeout: 245 seconds]
q9929t has joined #lisp
q9929t has quit [Client Quit]
vilivulpine has quit [Remote host closed the connection]
heisig has quit [Quit: Leaving]
robdog has joined #lisp
q3d has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
kini has quit [Quit: No Ping reply in 210 seconds.]
ebrasca has quit [Remote host closed the connection]
jprajzne has quit [Remote host closed the connection]
lumm has quit [Quit: lumm]
lumm has joined #lisp
dale has quit [Quit: dale]
dale has joined #lisp
ebrasca has joined #lisp
robdog has joined #lisp
kini has joined #lisp
jack_rabbit has quit [Ping timeout: 264 seconds]
robdog has quit [Ping timeout: 252 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
robdog has joined #lisp
sjl_ has joined #lisp
sjl_ has quit [Client Quit]
sjl_ has joined #lisp
<pfdietz_>
Right. I was mistakenly thinking there was no way to get the displaced-to of a displaced array.
robdog has quit [Ping timeout: 252 seconds]
<pfdietz_>
If there were no such way, they GC could be implemented to prune off the dead parts of an array. But the presence of that function means that's not possible.
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
milanj has joined #lisp
robdog has joined #lisp
LdBeth has quit [Ping timeout: 252 seconds]
dtw has quit [Ping timeout: 252 seconds]
dtw has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
igemnace has quit [Ping timeout: 245 seconds]
myrkraverk has quit [Ping timeout: 268 seconds]
robdog has quit [Ping timeout: 252 seconds]
<jcowan>
pfdietz_: True, but displacement is not very flexible
<jcowan>
(unlike proper slices)
<jcowan>
CL standardized arrays too early, I think
<jcowan>
(so did Fortran, I don't blame the WG for that)
robdog has joined #lisp
jb__ has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: Leaving]
jb__ has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
rumbler31 has joined #lisp
robdog_ has joined #lisp
p0a has joined #lisp
shka_ has joined #lisp
<p0a>
Hello, I've just gotten practical common lisp and I'm reading through
robdog has quit [Ping timeout: 252 seconds]
<p0a>
I'm curious about this, is common lisp faring well with concurrency? I recall that's the weak spot, is that right??
<p0a>
then again not sure why a pthread wrapper wouldn't just do the trick (on the other hand, I have next to zero experience with concurrency)
robdog_ has quit [Ping timeout: 252 seconds]
fortitude has joined #lisp
robdog has joined #lisp
<jackdaniel>
p0a: it is not a weak spot, it is just not part of common lisp standard
<p0a>
so there's good efforts out there, just not standard?
<jackdaniel>
(concurrency is not part of C89 standard either fwiw)
<p0a>
yeah I'm aware, neither of C99 I believe
<jackdaniel>
standard dictates what implementation must offer, implementations may provide more
<jackdaniel>
in fact most implementations *do* provide threading primitives
<jackdaniel>
moreover there is a portability layer which unifies interface for basic functionality
<jackdaniel>
it is called bordeaux-threads
<p0a>
I knew of bsd threads
<jackdaniel>
it is available in quicklisp (or from git whatever)
<jackdaniel>
bordeaux-threads is a portability layer which maps onto implementation-specific threading (which, in turn, may use pthreads underneath; this is not important in usual case)
<jackdaniel>
maybe some scheme evangelist said something like: common lisp has a well-defined order of evaluating function arguments, that's why they can't be evaulated in parallel
<jackdaniel>
this argument is a hoax
<p0a>
why?
<jackdaniel>
because you may evaluated arguments before applying to a function and that's all there is to it. abstracting it with macro is trivial
<jackdaniel>
evaluate*
FreeBirdLjj has quit [Remote host closed the connection]
<p0a>
I see, so instead of (f g h) you want (f g* h*) with g* and h* the evaluated versions of g and h?
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<jackdaniel>
and defined order of evaluation to a function is an adventage from the intuitivity point of view
<jackdaniel>
p0a: yes, lparallel has stuff like that, for instance "pmap"
<jackdaniel>
plet and many more
<p0a>
got it
<p0a>
okay I just wanted to make sure
<p0a>
for some reason it really killed my mood back in the day
<p0a>
when people made those arguments about how CL is dead
<p0a>
because of concurrency
<p0a>
I mean, I believed them I suppose
<jackdaniel>
there is a lot of fear, uncerntainity and despair on the internet, rarely founded on a reality
<jackdaniel>
(notice what I did there: THE internet, A reality ;-)
<p0a>
lol
<p0a>
stuff to think about
FreeBirdLjj has joined #lisp
jmercouris has joined #lisp
robdog has joined #lisp
CrazyEddy has joined #lisp
<jmercouris>
does anyone know how ot make sxql order-by return order-by instead of order by?
<jmercouris>
(sxql:order-by (:desc :id))
<jmercouris>
#<SXQL-CLAUSE: ORDER BY id DESC>
<jmercouris>
whereas I need: #<SXQL-CLAUSE: ORDER-BY id DESC> for Postgresql
<p0a>
np I helped you using my google skills, literally knowing nothing about the subject(s). :P
<jmercouris>
well, I haven't confirmed your solution works yet :D
<p0a>
I was hoping I was right.
<jmercouris>
I'm hoping you're right
<p0a>
i scream you scream for ice cream
rumbler31 has quit [Remote host closed the connection]
<jmercouris>
You are right
<jmercouris>
you are my savior, thank you so much
<p0a>
you're welcome
<jmercouris>
I was thinking it was some stupid syntax of order by vs order-by
<p0a>
yeaaah it sounded kind of suspicious
<jmercouris>
I guess postgres is a bit more forgiving than I thought!
<p0a>
because the author of SxQL didn't mention thigns like that
<jmercouris>
indeed they didn't
<jmercouris>
I don't know if they use mysql though, or what
milivoj has quit [Ping timeout: 240 seconds]
igemnace has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<p0a>
I'm pretty glad about getting practical common lisp
<p0a>
I think it's the first programmign book I'll read in hard copy
<p0a>
lol
<p0a>
shame on me
<jmercouris>
be proud, you saved many a tree life
<p0a>
there are still naive people in this world who believe in saving trees
<p0a>
the end is coming! woo
<p0a>
anyway, on that note, I have to go. Thanks for the chat and help
JohnMS_WORK has quit [Read error: Connection reset by peer]
p0a has quit [Quit: bye]
elderK has quit [Quit: Connection closed for inactivity]
<pjb>
Using paper is saving trees, since the paper industry must replant trees to continue producing paper. If you stop using paper, then you kill trees!
sunwukong has quit [Read error: Connection reset by peer]
myrkraverk has joined #lisp
amerlyq has quit [Quit: amerlyq]
<dlowe>
failure to create more trees isn't the same as killing trees
<dlowe>
despite the similar outcome on the net tree quantity
LiamH has joined #lisp
varjag has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
frodef has joined #lisp
CCDelivery has joined #lisp
<jmercouris>
dlowe: don't bring logic into this discussion, what do you think this is, some computer science channel?
<jmercouris>
this channel is *STRICTLY* L I S P
<jmercouris>
just in case it is unclear, I am making a joke, and with that, signing off, goodbye everyone, and thanks for all the fish!
jmercouris has quit [Remote host closed the connection]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
hhdave has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
igemnace has quit [Ping timeout: 240 seconds]
robdog has quit [Ping timeout: 245 seconds]
nalkri has joined #lisp
Zaab1t has joined #lisp
phoe has joined #lisp
<varjag>
is there a channels library that's considered reasonably stable?
<varjag>
i remember looking into trivial-channels couple years ago, they had some subtle bug
bandrami has joined #lisp
ravenousmoose has joined #lisp
<varjag>
hm there are some in lparallel
m00natic has quit [Remote host closed the connection]
DGASAU has quit [Read error: Connection reset by peer]
robdog has joined #lisp
bandrami has quit [Quit: Leaving]
robdog has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
DGASAU has joined #lisp
karlosz has joined #lisp
bendersteed has joined #lisp
hiroaki_ has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
ggole has quit [Quit: Leaving]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 252 seconds]
nanoz has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
bendersteed has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
karlosz has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
karlosz has quit [Client Quit]
nalkri has quit [Ping timeout: 252 seconds]
nowhereman has joined #lisp
Josh_2 has joined #lisp
robdog has joined #lisp
<p_l>
varjag: "channels" is a bit unspecified term
CCDelivery has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
Zaab1t has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
rozenglass has quit [Ping timeout: 244 seconds]
robdog_ has joined #lisp
cl-arthur has quit [Ping timeout: 245 seconds]
ravenousmoose has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
milanj has quit [Quit: This computer has gone to sleep]
robdog_ has quit [Ping timeout: 252 seconds]
<varjag>
p_l: the trivial-channels kind of channels
Adamclisi has quit [Remote host closed the connection]
<varjag>
which i believe were inspired by golang
bendersteed has joined #lisp
<p_l>
the better keywords for the search would be "CSP" aka "Communicating Sequential Processes"
cage_ has quit [Remote host closed the connection]
makomo has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<jasom>
I like lparallel, but I have learned that you should use separate kernels for separate parts of your processing pipeline. I actually independently discovered that, but recently saw a blog article to that effect as well.
<jasom>
this issue would be solvable with a solid green-threads implementation (where any blocking would free up a worker thread), but N to M green threads are non-trivial.
Ricchi has joined #lisp
<jasom>
And green threads at all in lisp require implementation help (green threads can be implemented as a library on top of a language with continuations, but even then getting I/O correct is a lot of work)
ebrasca has quit [Remote host closed the connection]
bendersteed has quit [Remote host closed the connection]
robdog has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
<pillton>
jasom: I think a better solution is a data flow framework with its own scheduler. As mentioned in the article above, you tag each "data flow processor" with the kind of work it does and configure the scheduler to use a certain number of threads for that type of task.
Tristam has quit [Excess Flood]
Tristam has joined #lisp
<jasom>
pillton: that's roughly what separate lparallel kernels would accomplish, right? i.e. if I were to implement a data flow framework with lparallel, each "kind of work" would be a kernel with a certain number of threads?
<jasom>
alternatively one could just ditch lparallel's kernels and just use the queue and then manage threads manually with BT
robdog has quit [Ping timeout: 252 seconds]
<pillton>
jasom: I have only looked at lparallel briefly. I think the queue's in lparallel assume one thread writes and another thread reads and blocks if data isn't available. You don't want this behaviour in data flow processing as it should be possible to execute a "flow"/graph with only one thread available.
<jasom>
pillton: lparallel has two types of queues; bounded and unbounded.
<pillton>
Right. You can only use bounded queues in data flow processing.
<jasom>
bounded queues block when the queue is full (which is what you want for producer-consumer in a multithreaded environment)
<jasom>
pillton: the whole point of PVK's article is that having separate thread pools for steps in the flow graph guarantees the consumer will always have at least 1 thread available for forward progress, right?
<jasom>
(assuming thread pool means 1 or more threads)
anewuser has joined #lisp
izh_ has joined #lisp
<pillton>
Right. I wasn't sure from the article if progress would occur with only one thread.
<pillton>
It depends on your communication strategy between workers.
robdog has joined #lisp
<jasom>
if you have only 1 thread, then a queue put becomes a function call.
<pillton>
Well, it seems to contradict that purpose of these libraries i.e. you want to take advantage of parallelisation, not require it.
<jasom>
If you wanted to sugar in allowing a step to have a thread-count of 0, and replacing channel (or queue) calls with a straightforward function call, you can certainly do that in the framework.
groovy2shoes has joined #lisp
<jasom>
but as long as blocking exists, you can't just ignore the number of threads involved.
<pillton>
I agree. It constrains the way you implement each unit of work.
<pillton>
All of it is doable if you use non-blocking I/O strategies.
robdog has quit [Ping timeout: 252 seconds]
<jasom>
which requires a lot of manual callback type things, or a real green-threads library that handles I/O.
<pillton>
No it doesn't. See basic-binary-ipc for an example.
<jasom>
pillton: well basic-binary-ipc essentially requires you to structure your code in a callback type manner. You get to write the event loop yourself though, which gives you some flexibility.
<jasom>
what do you do if you receive a partial message with b-b-i? Save it somewhere and wait for more...
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<pillton>
No, you send a message to yourself to tell you to try reading at a later date.
lavaflow_ has quit [Read error: Connection reset by peer]
<jasom>
accomplishing that in a single thread sounds tough.
lavaflow_ has joined #lisp
<pillton>
It may be. I'll let you know when it is finished.
<jasom>
:D
<jasom>
also polling is notoriously inefficient, to the point that creating a single thread just for b-b-i might be easier.
robdog has joined #lisp
<pillton>
Well, my view at the moment is that if there are no other items of work then you can block.
<jasom>
How do you block on (or <any queue> <any socket>)?
<jasom>
In the past I've done that by having a thread for all sockets that just sends to a queue when there is data. Not strictly single-threaded, but all non-socket code is single threaded then.
<jasom>
if that was unclear, it's 1 thread total for all sockets, not 1 thread for each socket.
<pillton>
I don't understand. You can wait for an event on multiple sockets.
robdog has quit [Ping timeout: 252 seconds]
<jasom>
right. The main-thread only waits on queues. The socket thread only waits on sockets and passes the data into queues.
<jasom>
because waiting on both a queue and a socket is not immediately obvious how to do.
karlosz has joined #lisp
dacoda has quit [Remote host closed the connection]
<pillton>
Yes. I don't have anything concrete yet, but I think it is doable.
karlosz has quit [Client Quit]
<Xach>
jasom: I've long thought of a trick for that that I've never tried in practice
<Xach>
and that's to have a pipe fd, and write a byte to it to wake up the io multiplexer when the queue (or other thread-related thing) is ready for action.
robdog has joined #lisp
<jasom>
Xach: I've seen things like that done before (works with socketpair() as well on windows).
<jasom>
though now that I think about it, if it's completely single-threaded new data can *only* come from I/O not queues.
<pillton>
Only if there is no other work to be done.
<jasom>
true.
<jasom>
but if you're not explicitly yielding to the scheduler, you'll never check for new data from sockets while there is still work to be done, no?
<jasom>
and if you are explicitly yielding to the scheduler, no need to block if there is still work to be done.
<pillton>
You send a message to yourself and let the scheduler take care of when you are executed next.
<jasom>
pillton: and that's where callbacks need to come in, right? How else to you tell the scheduler what to run when you are next executed?
<pillton>
It isn't a callback. You send data to one of your input ports telling you to "process" that data.
robdog has quit [Ping timeout: 252 seconds]
<pillton>
I hate the word callback and all it encompasses. It is the one thing I want to avoid.
<jasom>
so the entire program is structured as a giant event loop, where input ports are mapped directly to single functions that will never block?
<pillton>
yes.
<jasom>
and input ports can be either sockets or some queue-like thing?
<pillton>
Just a queue-like thing.
<jasom>
oh
<jasom>
so one input port will map to "try to read from a socket" and if there is insufficient data, then you tell the scheduler to try again in the next loop?
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<jasom>
by passing a message back to the same input
<pillton>
Yes, but only if there is other work to be done.
<jasom>
and if there is no other work to be done the scheduler will block on any data from a socket.
<jasom>
to prevent spinning in the idle case
<pillton>
No, the scheduler won't block, the unit responsible for reading the sockets will.
<jasom>
so that unit needs to be intrusive into the scheduler, at least to the point of querying if we are currently idle.
<pillton>
I'm not sure I'd use the word intrusive, but yes.
<jasom>
I guess the scheduler's public API must include an okay-to-block-p predicate
robdog has joined #lisp
<pillton>
Yes. It isn't clear if this is a good idea when you have N threads though. I need to check that.
<jasom>
It would seem to me that sockets would need at least 3 slots: the actual socket object, a buffer (for partial messages) and which input channel to message when new data arrives.
<pillton>
Anyway, I have to go. My apologies for joining the conversation and running off. The kids are making a lot of noise about breakfast.
<jasom>
Then you can have a socket pass through a state machine by changing the input channel on state transitions
<jasom>
pillton: go feed kids!
vlatkoB has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
warweasle has joined #lisp
<jxy>
Do you guys see drawterm gets killed by SIGPIPE even with aan?
<Xach>
jxy: no
<Xach>
jxy: what is drawterm?
<jxy>
I had to put 'signal(SIGPIPE, SIG_IGN);' in 'osinit' to stop it generating SIGPIPE
<jxy>
sorry, I'm writing on a wrong channel
<Xach>
jxy: phew
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Achylles has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
trocado has joined #lisp
robdog has joined #lisp
adolby has quit [Ping timeout: 246 seconds]
trocado has quit [Read error: Connection reset by peer]
trocado has joined #lisp
xkapastel has joined #lisp
adolby has joined #lisp
ravenousmoose has joined #lisp
LdBeth has joined #lisp
<LdBeth>
Hola
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
<no-defun-allowed>
are there any portable unexec implementations around? i heard several lisp systems require some kind of unexec to write binaries
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
hiroaki_ has quit [Ping timeout: 250 seconds]
<akater>
p_l: In an emacs chat. I know, it's quite ridiculous.
<akater>
In article “The Anatomy of a Loop” www.ccs.neu.edu/home/shivers/papers/loop.pdf author says “another issue with [SERIES] iterations is that they don't nest”. Does anyone understand what it means?
<akater>
I wish SERIES had something along the lines of #2Z((1 2 3 ...) (a b c ...)), maybe this was the point. But maybe I'm missing something else.
robdog has quit [Read error: Connection reset by peer]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<LdBeth>
<no-defun-allowed "are there any portable unexec im"> #'no-defun-allowed: I don't think so, because it's GNU C lib specific
q3d has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
really? even on, say, macOS? there's an unexmacos.c in my Emacs
<p_l>
unexec is essentially emacs' implementation of core dumping and loading
<p_l>
so it has to implement it in some form everywhere
<no-defun-allowed>
right
<no-defun-allowed>
are there any implementations of unexec that i can use for a new lisp system?
<p_l>
no-defun-allowed: I wouldn't bother
<p_l>
emacs' implementation is afaik pretty... weird
<no-defun-allowed>
):
robdog has joined #lisp
<p_l>
I'd recommend looking at how SBCL/CMUCL handle it, or CCL.
<jasom>
no-defun-allowed: IIRC the emacs unexec assumes malloc() will be used for allocating memory; most lisp implementations that dump images manage the heap themselves.
<no-defun-allowed>
right
<no-defun-allowed>
ah, true
<p_l>
though arguably CMUCL/SBCL image format is ancestor of the format used by executables/libraries in Mach (including OSX)
hiroaki_ has joined #lisp
<no-defun-allowed>
i'll probably use malloc to allocate a heap then carve that out cause i'm bad at c
<jasom>
I believe that ecl uses malloc, but it also doesn't dump images, though it's possible that unexec would allow it too (at least in single-threaded programs).
<p_l>
don't use malloc
<p_l>
it's shitty even in C
<no-defun-allowed>
i know but i'm shit at C
<jasom>
no-defun-allowed: mmap() is your friend for getting a large chunk of address space.
<no-defun-allowed>
right
scymtym has quit [Ping timeout: 240 seconds]
<p_l>
no-defun-allowed: SBCL-style use of mmap() is easier than grokking what actually happens with malloc()
<p_l>
I'd even say that a two-space copying collector is easier than malloc
<no-defun-allowed>
lol yeah
<jasom>
a non-generational two-space collector is *far* easier than all but the dumbest malloc implementations.
<jasom>
Cheney's algorithm is so simple; literally the only hard part is getting the roots.
<jasom>
which reminds me of a question; does the ARM64 sbcl use the non-conservative (split-stack) collector, seeing as ARM64 has 31 GPRs?
robdog has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
pretty sure everything that isn't x86 uses non-conservative GC
<jasom>
no-defun-allowed: I hope 32-bit ARM didn't it had something like 14 GPRs..
lucasb has quit [Quit: Connection closed for inactivity]
<jasom>
that would be a big performance hit.
<no-defun-allowed>
dunno, that's 7, x86 had 4 GPRs to my knowledge
warweasle has quit [Quit: mind break at line 1239328732753 in module "__soul(dllspec)"]
<jasom>
x86-64 uses the conservative GC and has 1 more GPR than ARM32 (since they both have nominally 16, but ARM includes the PC in that and AMD64 does not).
robdog has joined #lisp
<jasom>
no-defun-allowed: 6 once you account for the extra stack and frame pointers. I suppose that's still more than x86.
<no-defun-allowed>
hmm, screw that idea of dumping an image then, is there a way to make libjit dump its code? (is there a #libjit?)
<jasom>
Benchmarking C code on POWER with reserving registers for globals, I found the performance drops rapidly until 18ish and then tapers off to the point where 24 is not measurably better than 32.
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
<LdBeth>
#'no-defun-allowed: if you are still curious on how Emacs works with unexec on mac, they just implemented unexec function in unexmacos.c with Darwin's api. And this is obviously not portable.
<no-defun-allowed>
yeah
<LdBeth>
JIT is a poor idea if you start something from scratch
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
<jasom>
yeah, libjit looks like a poor match; it has nested functions but they are not allowed to outlive their parents.
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
rumbler31 has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
shka_ has quit [Ping timeout: 255 seconds]
robdog has joined #lisp
Fare has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
ebrasca has joined #lisp
ltriant has joined #lisp
<Xach>
only downards-funargs??
rumbler31 has quit [Remote host closed the connection]
marcoecc has quit [Remote host closed the connection]
<jasom>
Xach: if F1 has nested function F2, only F1 and children of F1 may call F2. It looks like libjit uses the C stack for all locals.
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
karlosz has joined #lisp
hil8 has joined #lisp
karlosz has quit [Client Quit]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
trocado has quit [Read error: Connection reset by peer]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
Bike has quit []
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
robdog has quit [Ping timeout: 252 seconds]
edgar-rft has joined #lisp
sjl_ has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
izh_ has left #lisp [#lisp]
dale has quit [Quit: dale]
lumm has quit [Quit: lumm]
dale has joined #lisp
lumm has joined #lisp
karlosz has quit [Quit: karlosz]
hil8 has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
hiroaki_ has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 252 seconds]
Aruseus has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 252 seconds]
dddddd has quit [Read error: Connection reset by peer]