Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
alphor has joined #lisp
SuperJen has joined #lisp
astronavt has quit [Quit: Leaving...]
astronavt has joined #lisp
jfb4 has joined #lisp
Guest35307 has quit [Ping timeout: 240 seconds]
yeticry has quit [Ping timeout: 260 seconds]
QualityAddict has quit [Ping timeout: 240 seconds]
QualityAddict has joined #lisp
antoszka has joined #lisp
<fe[nl]ix>
Shinmera: or get rid of recursive locks entirely
billstclair has joined #lisp
jeremyheiler has joined #lisp
banjiewen has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
quotation_ has quit [Quit: Connection closed for inactivity]
QualityAddict has quit [Ping timeout: 248 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
lnostdal has joined #lisp
QualityAddict has joined #lisp
turkja has joined #lisp
<jasom>
_death: because the results (which are going out to a file) could be many gigabytes, unless I'm misunderstanding you what you suggest would keep them all in ram
* jasom
had a patch to BT that errord on acquire-recursive-lock on sbcl, not sure what happened to it
* jasom
also had a patch that implemented proper recursive locks, but that was met with ambivalence
raphaelss has quit [Ping timeout: 248 seconds]
gz_ has quit [Ping timeout: 258 seconds]
asedeno has quit [Ping timeout: 258 seconds]
gz_ has joined #lisp
asedeno has joined #lisp
<Ober>
jasom: they welcomed it with open arms?
<_death>
jasom: makes sense, but you could still have syntax similar to the naive approach doing it efficiently
Jen has joined #lisp
Jen is now known as Guest56590
Amplituhedron has quit [Ping timeout: 260 seconds]
SuperJen has quit [Ping timeout: 250 seconds]
<jasom>
_death: yeah, I might be able to macroize what I have now.
epony has quit [Quit: QUIT]
papachan has quit [Quit: WeeChat 2.0]
<_death>
jasom: I'm thinking (dolist (promise (mapcar #'future-it-out chunks)) (write (force promise))), no need to explicitly deal with tasks and queues
<jasom>
_death: ah, that will create a lot of promises; If we have 100GB of data and the average cunk size is ~60k what's the math on that?
<jasom>
~2M promises. Not sure how heavy promises are
epony has joined #lisp
<_death>
jasom: right, so it could have a mapcar-like operator or some kind of dolist/mapcar operator..
<jasom>
"pipeline"
<jasom>
or scatter-gather or something
<_death>
right
yeticry has joined #lisp
<jasom>
There are 3 parts: 1) generate work 2) do work in parallel 3) handle results in order
red-dot has joined #lisp
zmt01 has joined #lisp
<jasom>
so the form I would like is (pipeline FUNCTION-THAT-GENERATES-1-WORK-ITEM-PER-CALL FUNCTION-THAT-DOES-WORK FUNCTION-THAT-HANDLES=-RESULT)
<jasom>
though I'm open to form over function
zmt00 has quit [Ping timeout: 240 seconds]
<_death>
maybe the fixed-capacity channel is a good abstraction here
<jasom>
oh, there's a fixed-capacity channel?
<jasom>
that would make the queue unneeded
<jasom>
oh, no that still doesn't work because you lose ordering
<_death>
no, I'm doing some wishful thinking :)
<jasom>
_death: you were right though, there is a fixed-capacity channel
<jasom>
but the queue is needed for ordering
<_death>
pipelining through a fixed-capacity channel
yeticry has quit [Ping timeout: 248 seconds]
<jasom>
pipelining through a fixed-capacity queue is what I'm doing
<_death>
so your pipeline function may take it as well
<jasom>
well if ordering is unneeded, a fixed-capacity channel already does what I need
<jasom>
I considered using that plus adding an index, but that's a lot more code than just using a queue
<_death>
do you really have to write it in order
<_death>
I suppose if it's stdout.. but if it's a file you don't need to
<jasom>
common usecase is pipe to tar
smurfrobot has joined #lisp
<_death>
hmmm.. at this point I'm thinking about rsync and a different flow :)
<Xach>
I would love to have a code search for quicklisp :~(
<Xach>
I think there are huge opportunities for something better than grepping and googling. so specialized.
<Xach>
like searching only for function calls or variable bindings or what have you.
margeas has quit [Ping timeout: 248 seconds]
Josh_2 has joined #lisp
<_death>
load all quicklisp libraries, dump and serve xref databases?
<Xach>
I'd love something like that
<Xach>
what packages does project XYZ define, what package(s) define package ABC, what functions have more than five required arguments, how many functions have &key and &optional, so many queries
zmt01 has quit [Quit: Leaving]
zmt00 has joined #lisp
Josh_2` has joined #lisp
<Xach>
it's all in there
<_death>
maybe a tool to dump such information for a given image
<Xach>
yes.
<Xach>
what is the most common variable name for the stream argument in with-open-file
Kundry_Wag has quit [Ping timeout: 246 seconds]
Josh_2 has quit [Ping timeout: 260 seconds]
<Bike>
i always thought gigamonkeys' "manifest" system, that displayed a state of the image to a browser, was really neat. i guess this would be like machine readable version. with export
Josh_2` has quit [Remote host closed the connection]
<_death>
could also be used to compare codebases on different implementations
<Xach>
Bike: right. you can't load everything in the same image, too.
<Xach>
I think an AOT manifest thing could be fun.
Kundry_Wag has joined #lisp
eschatol_ has joined #lisp
yeticry has quit [Ping timeout: 240 seconds]
<pillton>
jasom: Are you expecting the work items generated by FUNCTION-THAT-GENERATES-1-WORK-ITEM-PER-CALL to be independent work items?
fikka has joined #lisp
<pillton>
Some "pipelines" can be naturally represented as a tree where the nodes at a specific depth in the tree represent independent work items.
fikka has quit [Ping timeout: 246 seconds]
SuperJen has joined #lisp
<jasom>
pillton: the work items are independent, but the generator may be ordered; I don't recall if it is ordered in this specific use-case, but I've had similar cases in the past where it is
<jasom>
pillton: I think in this use case it is not ordered (i.e. I can generate the Nth item in O(1) time)
Guest56590 has quit [Ping timeout: 248 seconds]
<jasom>
the main thing is I have something that generates data, some work to do, and something that collects the data (which requires it be collected in-order).
<jasom>
the work is by far the most expensive part, and in this case generating the data in parallel makes no sense, since it would require locking an external resource.
lrvy has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
jfb4 has quit [Ping timeout: 240 seconds]
eSVG has joined #lisp
Kundry_Wag has joined #lisp
grublet has quit [Quit: Leaving]
<jasom>
the other thing that e.g. unix pipelines have that I don't need in this *specific* case, but could use in other cases is backwards propagation of early termination. (i.e. I have "enough" now, so I need to tell the generator to stop)
pjb` has joined #lisp
pjb has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
vibs29 has quit [Ping timeout: 240 seconds]
whoman has quit [Read error: Connection reset by peer]
vibs29 has joined #lisp
d4ryus1 has joined #lisp
whoman has joined #lisp
<jasom>
in any event, the queue of promises is at least clear and simple enough to reason about that I don't have a big complaint.
Acherontius has joined #lisp
<eschulte>
Is it possible to use ASDF build-op to build multiple binaries from a single package, or do I need to write a separate .asd file for each compiled binary?
Acherontius has left #lisp [#lisp]
d4ryus has quit [Ping timeout: 240 seconds]
marvin3 has joined #lisp
nullniverse has joined #lisp
<jasom>
eschulte: I think the suggestion there is to have multiple systems in the same .asd
<jasom>
e.g. foo/binary1 foo/binary2
<eschulte>
ah, that's reasonable, thanks
<jasom>
if you use "/" to separate the primary name from the sub-name, then asdf will know which .asd file to look in
<Fare>
eschulte, as jasom said, you can depend on multiple secondary systems.
Kundry_Wag has joined #lisp
<eschulte>
Fare: I just converted my asd to use multiple defsystems, and that seems to be working well
<Fare>
PROBLEM, though, is that dumping a binary, at least on SBCL, kills the current process
<Fare>
so, you'll have to tweak the build slightly to do that in a fork.
zu22 has joined #lisp
<Fare>
maybe by using POIU
lagagain has quit [Quit: Connection closed for inactivity]
<Zhivago>
Don't they have an option to fork-and-dump?
<Fare>
what implementation are you using?
<eschulte>
ah, that makes sense. I think the multiple independent defsystems will work well with my current top-level Makefile driver
<eschulte>
sbcl and ccl
<Fare>
of course, ASDF can't do it in a fork by default, since fork is not portable to all systems that sbcl runs on (e.g. Windows), and fork isn't safe if you started threads already.
<Fare>
not my problem anymore. Good luck to the next ASDF maintainer.
<pillton>
eschutle: FWIW Lisp-executable has that functionality.
<Fare>
When my current branches are all merged, I'm off.
<Fare>
I don't support lisp-executable. It might even be massively broken since ASDF 3.
<eschulte>
Fare: congratulations on handing off to a new maintainer
<Fare>
I haven't handed off anything. There is no new maintainer to replace me. I'm just going to drop it off.
<Fare>
I mean, rpgoldman is the new maintainer, but he has even less time than I to work on it
<Fare>
and has been the new maintainer since ~2014.
<Fare>
he certainly has made ASDF more conservative and higher quality than if I were still breaking things around
paraparity has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
earl-ducaine has quit [Remote host closed the connection]
earl-ducaine has joined #lisp
<eschulte>
that last part sounds pretty good, given that there already appears to be a good deal of functionality
<eschulte>
I've got to run, I'm excited how easy building packages with asdf has been so far though, many thanks for the tips!
emacsoma` has joined #lisp
aristippus has joined #lisp
<pillton>
Fare: It works on ASDF 3.
damke_ has joined #lisp
kolb has quit [Ping timeout: 250 seconds]
damke has quit [Ping timeout: 246 seconds]
tonton has quit [Ping timeout: 268 seconds]
tonton has joined #lisp
marusich has joined #lisp
emacsoma` has quit [Remote host closed the connection]
emacsoma` has joined #lisp
<Fare>
pillton, on 3.3 ?
rpg has joined #lisp
zu22 has left #lisp [#lisp]
<pillton>
I haven't tried 3.3. It works with 3.1.5.
emacsoma` has quit [Ping timeout: 248 seconds]
marusich has quit [Ping timeout: 255 seconds]
<jasom>
Fare: If I haven't said it already, I appreciate how much work you've put into not just dropping it and running away.
Kundry_Wag has quit [Remote host closed the connection]
mrottenkolber has joined #lisp
Kundry_Wag has joined #lisp
mrottenkolber is now known as Guest1085
emacsoma` has joined #lisp
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
Guest1085 has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Ping timeout: 255 seconds]
mrottenkolber_ has joined #lisp
vtomole has joined #lisp
fikka has joined #lisp
rumbler31 has quit []
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
bugrum has quit [Remote host closed the connection]
paraparity has quit [Remote host closed the connection]
marusich has joined #lisp
rvirding has quit [Ping timeout: 258 seconds]
rvirding has joined #lisp
dieggsy has joined #lisp
resttime has joined #lisp
EvW has joined #lisp
ahungry has joined #lisp
rpg has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
<Fare>
jasom, thanks :-)
<Fare>
but that won't last
<rpg>
Does anyone have a Jenkins recipe for working with quicklisp? I.e., having a module that is checked out of a repository, but goes into a quicklisp/local-projects/ for jenkins?
<Fare>
#gerbil-scheme is already my primary Lisp platform these days.
<Fare>
I still believe it deserves your review, because it has future implications.
<Fare>
see notably commit message for 8e68ac229c19b7b611caf942a7f0998c88047a79
<rpg>
Fare: No problem -- it's just run through my Jenkins tests and it seems fine. I'll take a more in-depth look, but I think the syntax control needs more concentration right now, now that I'm back from my travels
<Fare>
oh, it passed all tests.
marusich has quit [Ping timeout: 276 seconds]
JuanDaugherty has quit [Remote host closed the connection]
<Fare>
And it only affects upgrade --- and whoever besides me would have been deep enough to extend bundle classes, which I think is no one (or there would have been a lot of complaints as I kept refactoring it over the years)
<Fare>
on the other hand, extending the same fix to other more basic operation classes might be harder, if anyone used them (which I bet at least someone would).
marusich has joined #lisp
<Fare>
syntax-control is probably more urgent.
<Fare>
and after that --- I'm free from ASDF hacking!
<Fare>
though I'll gladly mentor a replacement... as long as the memories are still there
hexfive has quit [Quit: WeeChat 1.9.1]
hexfive has joined #lisp
turkja has quit [Ping timeout: 246 seconds]
turkja has joined #lisp
test1600 has joined #lisp
raphaelss has joined #lisp
<rpg>
bah! I'm going to have a glass of wine... Once more getting my bloody tests to work right is harder than getting the code under test to work right -- for reasons totally unrelated to the code under test.
dieggsy has quit [Remote host closed the connection]
<Fare>
rpg: just pushed minor updates to TODO
<Fare>
beach: chào anh
<beach>
Hey. What's up?
vtomole has quit [Ping timeout: 260 seconds]
pierpa has quit [Quit: Page closed]
<Fare>
lots and lots
Bike has quit [Quit: Lost terminal]
<Fare>
trying to recruit for various software startups... Scheme, Common Lisp, OCaml, F#
<beach>
Oh? You are a head hunter now?
test1600 has quit [Quit: Leaving]
smurfrobot has joined #lisp
BitPuffin|osx has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
marusich has joined #lisp
turkja has quit [Ping timeout: 240 seconds]
turkja has joined #lisp
<Fare>
kind of
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Xal has quit [Ping timeout: 240 seconds]
Xal has joined #lisp
king_idiot has quit [Ping timeout: 255 seconds]
GGMethos has quit [Ping timeout: 258 seconds]
GGMethos has joined #lisp
<beach>
I see.
jfb4 has quit [Ping timeout: 240 seconds]
jfb4 has joined #lisp
circ-user-LLSO9 has joined #lisp
bugrum has joined #lisp
dddddd has quit [Remote host closed the connection]
circ-user-LLSO9 has quit [Remote host closed the connection]
red-dot has joined #lisp
rumbler31 has quit [Remote host closed the connection]
astronavt has quit [Quit: Leaving...]
froggey has quit [Ping timeout: 250 seconds]
<whoman>
CL+ocaml is good match/mix
emacsomancer has quit [Ping timeout: 276 seconds]
emacsomancer has joined #lisp
vlatkoB has joined #lisp
marusich has quit [Ping timeout: 246 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 246 seconds]
marusich has joined #lisp
<beach>
I don't believe it is good to mix languages.
froggey has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
marusich has quit [Ping timeout: 255 seconds]
yeticry has joined #lisp
marusich has joined #lisp
bugrum has quit [Remote host closed the connection]
<Fare>
beach: trying to recruit for me + friends.
<Fare>
beach: I don't believe it either -- they are separate projects
<Fare>
I try to do everything in Gerbil Scheme
<Fare>
and to make Gerbil Scheme more Common Lisp like where it is lacking
<beach>
So you have a startup with a friend?
<Fare>
yes
<beach>
Nice!
<Fare>
BTW, do you have contacts in VN?
<beach>
Yes, I do.
<beach>
A French guy who does contractual software work.
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<Zhivago>
Gerbil looks nice, but unexceptional, at a glance -- what motivated the new dialect?
igemnace has joined #lisp
<Zhivago>
(Not that I'm criticizing -- I just couldn't see the reason so far)
lisp_guest has joined #lisp
Jen has joined #lisp
Jen is now known as Guest36852
yeticry has quit [Ping timeout: 240 seconds]
SuperJen has quit [Ping timeout: 248 seconds]
Karl_Dscc has joined #lisp
wigust has quit [Ping timeout: 255 seconds]
xantoz has quit [Ping timeout: 240 seconds]
raphaelss has quit [Remote host closed the connection]
<beach>
Fare: You might have mail.
anunnaki has quit [Ping timeout: 240 seconds]
marusich has quit [Ping timeout: 255 seconds]
ahungry has quit [Remote host closed the connection]
yeticry has joined #lisp
dec0n has joined #lisp
lisp_guest has quit [Ping timeout: 255 seconds]
jack_rabbit has quit [Read error: Connection reset by peer]
hexfive has quit [Quit: WeeChat 1.9.1]
mishoo has joined #lisp
oleo has quit [Quit: Leaving]
<Ober>
beach is an anh? not an ong?
asarch has quit [Quit: Leaving]
Karl_Dscc has quit [Remote host closed the connection]
* Ober
thought he was older
fikka has joined #lisp
<beach>
I prefer anh. I don't feel old.
<Ober>
:P one day... you find folks using ong. and go .wtf. when did that happen
resttime has quit [Quit: Leaving]
<beach>
Yeah, I have had that happen to me.
fikka has quit [Ping timeout: 248 seconds]
igemnace has quit [Quit: WeeChat 2.0]
flamebeard has joined #lisp
jack_rabbit has joined #lisp
zmt00 has quit [Quit: Leaving]
<shka>
i have no idea what you are talking about :D
<lieven>
at a guess, some asian language with different pronouns for people older or younger than you :)
<shka>
this may or may not be the case!
<lieven>
kind of like you young whippersnappers should get off my lawn
<Ober>
essentially family role names used as pronouns.
<beach>
Vietnamese.
<shka>
gosh
<shka>
well good for you
<lieven>
Thai seems similar. Some of my Thai acquaintances want to find out a person's age when they first meet someone.
<beach>
It is an interesting situation of negotiation. Things are a bit simpler for me because I am both older than most people I deal with, and I have a higher rank.
<beach>
Like I said, it's a matter of negotiation and of relative age, etc, etc.
trosa-work has quit [Remote host closed the connection]
<beach>
ông: grandfather, old man, gentleman, you (used by grandchild to grandfather), I (used by grandfather to grandchild, you (used to men), he (of men over 30), husband, man, Mr.
<beach>
From my electronic dictionary.
Jen has joined #lisp
Jen is now known as Guest97197
<loke`>
beach: Seems complicated. :-)
<beach>
But fun, too. :)
<loke`>
beach: American is easier: “Yo! dude”
<beach>
Yes, but then English has verb conjugations, tenses, etc.
<loke`>
beach: Hey! I spend my time on social media. I see no traces of such fancy languageisms there.
<beach>
I go store soon. No have time talk here.
<Zhivago>
loke: Well, you have similar rules regarding the use of words like "mister" and "sir".
SuperJen has quit [Ping timeout: 260 seconds]
<beach>
At Johns Hopkins, we called the teachers "Dr <last-name>".
<loke`>
beach: See? You understand now.
jack_rabbit has quit [Ping timeout: 248 seconds]
xantoz has joined #lisp
tcr has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
SuperJen has joined #lisp
Ven`` has joined #lisp
Ven`` has quit [Client Quit]
Guest97197 has quit [Ping timeout: 240 seconds]
jack_rabbit has joined #lisp
<Shinmera>
fe[nl]ix: Removed recursive lock usage from simple-tasks
fikka has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
<Ober>
Error: Last argument to apply is too long:. uff. must use reduce and not apply for 6k items
smurfrobot has joined #lisp
yeticry has quit [Ping timeout: 250 seconds]
yeticry has joined #lisp
<aeth>
clisp has a call-arguments-limit of 4096. Every other implementation that I've checked is *much* higher than that, at least 60k. SBCL's is practically infinite (you'll run out of memory first)
<Ober>
aeth: lw has a limit.
<Ober>
call-arguments-limit
d4ryus1 is now known as d4ryus
<aeth>
If you're trying to be absolutely portable, 50 is the limit.
<Ober>
ok
<aeth>
LW is 4096, too?
<Ober>
checking
<Ober>
2047 on 7.1
<aeth>
oh, wow
<Ober>
writable though, the var is.
<Ober>
or not
<aeth>
Someone needs to compile a list of the various actual limits and sizes because the minimums in the CLHS are much lower than any implementation, but some implementations still have surprisingly low numbers
<jackdaniel>
except some heavy autogenerated code, why would you need more than 50 arguments?
<jackdaniel>
50 is absurdly high number already
<aeth>
jackdaniel: apply could be used in serialization because you can apply a plist, which would make it very convenient for serialization
<aeth>
You'd probably wind up with less than 2000, but possibly more than 50
<aeth>
(i.e. an applied plist becomes keyword arguments)
<aeth>
And yes, that would be heavily autogenerated.
<jackdaniel>
doesn't sound like a plausible use case
<jackdaniel>
either way, you can't count on more than what clhs specifies
<jackdaniel>
you never know when new implementation comes to play
fikka has joined #lisp
<aeth>
very useful.. (apply #'make-array 42 '(:element-type 'single-float :initial-element 42f0))
<jackdaniel>
it might be that after nuclear disaster, 2000 years from now, people will try to recreate machines capable of running program of our age
<jackdaniel>
don't make their work harder than it must be ;-)
<aeth>
jackdaniel: Someone should make a revised CLHS and only bump up the minimums for things. Or, actually, define separate 32-bit and 64-bit minimums. Iirc, a fixnum is only 16 bit as a minimum, which is tiny.
<aeth>
And very long docstrings could easily go over the 1024 size limit
smurfrobot has quit [Remote host closed the connection]
zhormistr has joined #lisp
Jen has joined #lisp
Jen is now known as Guest25157
<Ober>
what is the proper way to replace if seen progn with cond? (cond ((seen ... in this case sees it as a function
<jackdaniel>
each clause cond is (test forms*), where test is arbitrary expression returning value
<jackdaniel>
if you put (seen 'foo) as test, then it will be evaluated
<jackdaniel>
(i.e function foo will be called)
<jackdaniel>
same as with test argument in IF operator
<Ober>
ok so under cond a single or double open paren before it should not confuse it. ok. must be error. lisp-critic cleanup
felideon has joined #lisp
kilimanjaro has joined #lisp
orivej has joined #lisp
SuperJen has joined #lisp
<lieven>
I remember 32 bit lispworks having some really annoying limits
Guest25157 has quit [Ping timeout: 255 seconds]
jfb4 has quit [Ping timeout: 268 seconds]
jfb4 has joined #lisp
grublet has joined #lisp
zhormistr has left #lisp [#lisp]
<aeth>
I think Common Lisp is a language that really only works with 36 bits or more.
<jasom>
You can have 31 bit fixnums on a 32 bit machine; if you require all allocations be 8-bit aligned, that still gives you two tag bits for non-fixnums
Amplituhedron has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
knobo1 has joined #lisp
jfb4 has quit [Ping timeout: 248 seconds]
jfb4 has joined #lisp
<Fare>
jasom: you mean 8-byte aligned.
<Fare>
And then, other types can have larger alignment, etc.
JenElizabeth has joined #lisp
<Fare>
and/or indirection
mishoo has quit [Ping timeout: 248 seconds]
SuperJen has quit [Ping timeout: 248 seconds]
SuperJen has joined #lisp
JenElizabeth has quit [Ping timeout: 240 seconds]
<jackdaniel>
interesting fact: chicken scheme has variable number of bits for immediate types
<myrkraverk>
Later, I have :with v := 10 ... and then :finally (return v) ; do I need the (return v) or is there another way to specify the return value of LOOP?
<mfiano>
certain clauses imply a return value, such as the last `collect`. You can either do it as you are now, or wrap it in a let variable.
<beach>
myrkraverk: collect, sum, etc provide a return value implicitly.
_Trasformatore_ has quit [Ping timeout: 276 seconds]
EvW has joined #lisp
<myrkraverk>
I'm doing custom arithmetic.
<myrkraverk>
On the buffer array.
<myrkraverk>
But maybe I can wrap in in :sum.
<mfiano>
I'm sorry not the last `collect` but all.
<myrkraverk>
I don't see a way to put my custom arithmetic in a :sum.
<myrkraverk>
so I'll keep my code as is.
<mfiano>
That is a fine choice.
<beach>
myrkraverk: No need to force it if it doesn't fit your needs. I was just answering your question.
<myrkraverk>
right, thanks
yeticry has quit [Ping timeout: 260 seconds]
hhdave has joined #lisp
Bike_ has joined #lisp
Bike_ is now known as Bicyclidine
cpape` has quit [Read error: Connection reset by peer]
wigust has joined #lisp
orivej has quit [Ping timeout: 255 seconds]
orivej has joined #lisp
murii has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
murii has quit [Ping timeout: 255 seconds]
orivej has joined #lisp
murii has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 268 seconds]
wheelsucker has joined #lisp
fikka has joined #lisp
cromachina has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 248 seconds]
quazimodo has quit [Ping timeout: 250 seconds]
Cymew has joined #lisp
EvW has joined #lisp
oleo2 has joined #lisp
yeticry has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
oleo has joined #lisp
Tobbi has quit [Remote host closed the connection]
orivej has quit [Remote host closed the connection]
Tobbi has joined #lisp
orivej has joined #lisp
xrash has joined #lisp
damke_ has joined #lisp
jmercouris has joined #lisp
warweasle has joined #lisp
damke has quit [Ping timeout: 246 seconds]
oleo2 has quit [Remote host closed the connection]
oleo2 has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
zaquest has quit [Remote host closed the connection]
oleo2 has quit [Quit: Leaving]
zooey has quit [Ping timeout: 248 seconds]
lnostdal has quit [Ping timeout: 248 seconds]
zaquest has joined #lisp
zooey has joined #lisp
<warweasle>
Can someone point me to a simple cl-autowrap project? Where they create the json files and then use them in their package.
<warweasle>
I meant .spec files.
<loke`>
warweasle: WHat is that?
<warweasle>
loke`: It's a quick way to make cffi bindings for C libraries.
igemnace has quit [Quit: WeeChat 2.0]
<loke`>
warweasle: Sounds liek a useful thing.
<loke`>
I have two CFFI-based projects on QL and I've created those binding smanually.
peterhil` has quit [Read error: Connection reset by peer]
<warweasle>
loke`: I have a couple too, but I want to redo them.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
peterhil has joined #lisp
Tobbi has joined #lisp
<jmercouris>
This is not strictly a common lisp question, but a regex one
FreeBirdLjj has quit [Remote host closed the connection]
<jmercouris>
I'm trying to figure out the regex to get "a string of stops salmon", and I want to find given input "st", the position of "stops" and "string"
<jmercouris>
I tried something like "\b["st"]" but I don't think that works
rumbler31 has joined #lisp
Guest28285 has quit [Remote host closed the connection]
Guest28285 has joined #lisp
hexfive has joined #lisp
<jmercouris>
I also tried \st\b but the syntax is confusing me, I got so used to emacs regex, and it keeps changing for every language
<jmercouris>
I wish there was a standardized way of writing regex
<Bicyclidine>
it kind of goes badly with the string syntax. for ppcre to see a backslash b, the lisp string would be "\\b"
<Bicyclidine>
"\b" means the b is escaped, so it's the same as "b"
<jackdaniel>
"\\b" means backslash b
<jackdaniel>
"\\\\b" is also funny
<jackdaniel>
all these are important for pathnames
<jackdaniel>
especially on windows
<jackdaniel>
and for arguments to run-program
<loke`>
jmercouris: I'm not sure I understand what you want... Do you want to match any word beginning with "st"?
<jmercouris>
loke`: correct
<loke`>
jmercouris: That's pretty easy
<Bicyclidine>
(ppcre:all-matches "\\bst" "a string of stops salmon") => (2 4 12 14)
<rumbler31>
there was a blog post on making this suck less in emacs
<loke`>
jmercouris: Use this: "\\W(st\w+)"
<jdz>
cl-ppcre also supports the symbolic notation.
<loke`>
Oops
<loke`>
jmercouris: Use this: "\\W(st\\w+)"
<warweasle>
In cl-autowrap, Am I supposed to export it's functions directly or are they just thin wrappers around the library?
<jmercouris>
I'll give it a try, thank you all for your help
<jackdaniel>
which comes from develop branch and it enables bunch of extensions which I hopefully fixed (at least from the compilation perspective)
<Xach>
jackdaniel: somewhat easy to try it
<jackdaniel>
I would appreciate it a lot, because I remember that last time I've touched these parts I've caused a regression
<Xach>
jackdaniel: are there runtime tests i could try?
<Xach>
for clx i worry that a successful build is only half the battle
FreeBirdLjj has quit [Ping timeout: 260 seconds]
<jackdaniel>
sure, I've added Display tests (activated with asdf:test-system). but for "visual" stuff you want clx/demo system – note that many demos there didn't work before PR
<jackdaniel>
I've tested changes with McCLIM on ECL, CCL and SBCL
<Xach>
how about stumpwm?
<jackdaniel>
and it worked fine (even better for CCL, because previously it didn't work with CLX when loaded from outside software/)
<jackdaniel>
I haven't
<jackdaniel>
I once tried to run stumpwm, but failed miserably (that was a few years ago)
<Xach>
at least it wasn't a few minutes ago, with your new branch!
<jackdaniel>
hm, I'll install xephyr then and try to debug. thank you
<jackdaniel>
Xach: it started for me from SBCL without a problem
<jackdaniel>
no rush, I'm finishing now my older PR with mapping-notify
Devon has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
markong has quit [Remote host closed the connection]
Cymew has joined #lisp
FreeBirdLjj has joined #lisp
<Fade>
well, stump builds clean.
<Fade>
I'll restart my session in a bit.
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
eudoxia has quit [Quit: Leaving]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 248 seconds]
bailon has quit [Ping timeout: 258 seconds]
Cymew has joined #lisp
tomlukeywood has quit [Read error: Connection reset by peer]
tomlukeywood1 has joined #lisp
bailon has joined #lisp
oleo2 has joined #lisp
<Fade>
my environment starts up, with no visible regression.
Cymew has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
Cymew has joined #lisp
<jackdaniel>
thank you
<jackdaniel>
Xach: do you have more details how it fails on your host?
oleo2 has quit [Quit: Leaving]
screaming_mouse has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
screaming_mouse has quit [Remote host closed the connection]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Cymew has quit [Ping timeout: 240 seconds]
epony has joined #lisp
Cymew has joined #lisp
FreeBirdLjj has joined #lisp
m00natic has quit [Read error: Connection reset by peer]
Devon has quit [Quit: rcirc on GNU Emacs 26.0.90]
Devon has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
FreeBirdLjj has quit [Ping timeout: 255 seconds]
turkja has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
SaganMan has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
SuperJen has joined #lisp
Guest28285 has quit [Ping timeout: 248 seconds]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
rm8 has quit [Remote host closed the connection]
rm8 has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
fikka has quit [Ping timeout: 276 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
epony has quit [Remote host closed the connection]
emaczen has joined #lisp
<emaczen>
how do I enforce a form to be accessible by only one thread at a time in terms of bordeaux threads?
<shka>
emaczen: use lock
<shka>
with-lock-held is a macro that ensures safety
<shka>
but basicly posix style mutexes
<shka>
emaczen: clear enough?
<emaczen>
shka: I think, I'm not that familiar with concurrency in general, but I understand the concept
<shka>
i see
<shka>
anyway, nothing fancy here
<shka>
BT is low (system) level system
rumbler31 has joined #lisp
<shka>
it offers basic stuff that can be used to build more complex logic
<emaczen>
Why do I have to create a lock here? Can't bt determine that entry into the form is what needs to be controlled?
<shka>
it can't
<shka>
anyway
<shka>
you don't control form
<shka>
you control access to variables
<shka>
you don't care about access to (+ 2 2)
<emaczen>
So you make locks around variables?
<shka>
but you care a lot about (incf a 2)
<shka>
more often then not, yes
<emaczen>
shka: Ok, I think I got it
<shka>
great
<shka>
von neuman machines are not all that lispy ;-)
FreeBirdLjj has joined #lisp
raphaelss has joined #lisp
<emaczen>
shka: is there a good mechanism for controlling forms? Is that desirable in lisp?
<emaczen>
emaczen: that is just kind of how I was thinking about it
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<shka>
emaczen: you don't want to control evaluation of forms, you want to control memory access
<shka>
that's one level below
<shka>
and with-lock-held is ok
<shka>
on sbcl, it will even error out when recursive lock will be performed
Ven`` has joined #lisp
<shka>
which is just great
<shka>
and saves a lot of time sometimes
<emaczen>
where exactly do you place your locks? I have a form which calls a function #'add-row which mutates a table, which is what I need to lock.
<emaczen>
err nvm
<emaczen>
Where do you place the bt:with-lock-held is what I meant
FreeBirdLjj has joined #lisp
<shka>
above setf!
<shka>
or aref
<emaczen>
Above code that calls setf?
<shka>
anyway, above access to memory
<shka>
(with-lock-held (lock) (aref a i j) (setf (aref a i j) 5))
<shka>
nothing related to lisp directly
<shka>
ok, got to go
<shka>
you will figure this out on your own
<lisp_guest>
emaczen: you want to scynchronize access to data, not code
<emaczen>
shka: thanks
<lisp_guest>
you place locks around code that works on data that's shared between threads
<lisp_guest>
the fundamental problem you want to avoid is basically 2 or more threads partying on the same memory at the same time
FreeBirdLjj has quit [Ping timeout: 246 seconds]
<emaczen>
how do I control a loop variable? (loop for var in vars do (bt:make-thread (lambda () ...)))
<shka>
emaczen: also, it is sometimes possible to avoid placing locks by using other guarantees of exclusive memory write
<lisp_guest>
emaczen: why would you control the loop variable?
<shka>
emaczen: establish new lexical env around make thread
<shka>
(loop for var in vars do (let ((var var)) (bt:make-thread (lambda () ...))
<lisp_guest>
shka: why would that be required? doesn't loop itself create a lexical binding?
<shka>
lisp_guest: loop establishes lexical envs just one, then it mutates bindings in it
<shka>
establishing separate env, will prevent inner var value from being changed by loop
<lisp_guest>
right, but it does so for every evaluation of LOOP
<shka>
exactly
<shka>
anyway, writing code like the above is not good idea
<shka>
if vars is very long, you will end up degrading performance!
<shka>
use lparallel and pmap
<lisp_guest>
hm, how does multithreading in lisp even work? i would expect every thread to have its own lexical bindings
<jasom>
lisp_guest: every thread also has its own dynamic bindings
<lisp_guest>
so how do you share data between threads?
<jasom>
lisp_guest: this is a de-facto standard (I think all implementations that implement threads do it), not part of the spec
<jasom>
lisp_guest: assignments are shared, bindings are not
<jasom>
lisp_guest: but ideally you don't share data between threads implicity anyways
<lisp_guest>
hm right, but in order to assign to something i need to have a binding first
<lisp_guest>
so if thread #1 has *var*, how does #2 assign to #1's *var*?
<jasom>
lisp_guest: defvar *assigns* not binds
<jasom>
(defvar *foo*) ... (setf *foo* 'bar)
<jasom>
If you are going to use threads, I highly recommend something like lparallel; if you type the word "mutex" enough times, you are going to have bugs.
<lisp_guest>
indeed, but understanding the fundamentals first is always good
<lisp_guest>
what do you mean by assigns though? doesn't DEFVAR create a dynamic binding?
<jasom>
lisp_guest: nope
<jasom>
it establishes a variable as special in the global scope.
<lisp_guest>
hm right, i was equating that with "making a binding"
<lisp_guest>
but a special variable can be unbound
<jasom>
If there is an optional value provided, it *assigns* not *binds*
tomlukeywood1 has left #lisp [#lisp]
<jasom>
that's because "bound" is used to mean "has a value" which is slightly different from "establishes a binding" because english doesn't have enough words...
<shka>
well, using mutex is that difficult on it's own, but there is much more required to implement efficient parallel program so if you are not using lparallel, you are wasting time
<shka>
*is not that
FreeBirdLjj has joined #lisp
<shka>
that's even true for the code above
<jasom>
shka: I strongly disagree with "is not that difficult"
<shka>
you can't just create one thread for each value in list!
<shka>
you don't want to have 10 000 threads
<shka>
you really don't
<shka>
and lparallel can take care of that for you
<jasom>
manually managing acesses to mutable shared state is futile in any non-trivial program.
yeticry has quit [Ping timeout: 240 seconds]
<shka>
also, lparallel has a lot more to often
<shka>
*offer
<shka>
plet, psort, ptree
<jasom>
I love lparallel because I can write my program sequentially, profile, and sprinkle in some parallel fairy-dust with almost zero effort
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
<lisp_guest>
jasom: oh, i'm not sure why i was confused. so DEFVAR/DEFPARAMETER act as if calling setf when setting the value, right?
<jasom>
lisp_guest: correct, it acts as SETF, not as LET
<shka>
at this point i think that not using lparallel for parallel programming is a waste of time :P
<jackdaniel>
lisp_guest: try typing one after another (defvar *foo* 3) (defvar *foo* 4) *foo*
<lisp_guest>
right. but i didn't mention DEFVAR anywhere above
<jackdaniel>
and (defparameter *bar* 3) (defparameter *bar* 4) *bar*
Ven`` has joined #lisp
<lisp_guest>
when you said that threads have their own bindings
<jasom>
lisp_guest: SETF on a special modifies the outtermost dynamic binding of it. If that binding was established in the current thread, it is invisible to all outer threads
<shka>
lisp_guest: assigments!
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<lisp_guest>
established by way of let i suppose jasom ?
<lisp_guest>
right. so if you don't rebind them, then *var* means the same thing in #1 and #2?
<jasom>
lisp_guest: yes
<lisp_guest>
i thought there was some invisible namespacing because of the way you put it at first
<jasom>
and if you do, then they are thread local
<lisp_guest>
right, exactly
<lisp_guest>
so then, synchronizing a LOOP variable is not required
<jasom>
and most threading libraries (including lparallel) let you setup variables that will get bound implicity on task creation, thus making them thread local. I use this e.g. for giving each thread a database connection.
fikka has quit [Ping timeout: 248 seconds]
<jasom>
lisp_guest: I think LOOP always establishes new bindings, so yes.
<jasom>
and it will work even if the loop variable is special.
<lisp_guest>
mhm, although, using special variables for loop counters is kinda weird, no?
<jasom>
lexical bindings are lexical. The lexical scope is unaffected by threading
<lisp_guest>
well, i guess you don't always need just counters
FreeBirdLjj has joined #lisp
<lisp_guest>
might want to loop over something global for some reason
<jasom>
(let ((x 1)) (bt:make-thread (lambda () (print x)))) <== does what you would expect.
<lisp_guest>
mhm
LocaMocha has quit [Ping timeout: 250 seconds]
rumbler31 has quit [Remote host closed the connection]
compro has quit [Ping timeout: 255 seconds]
yeticry has joined #lisp
<jasom>
so you can also use lexical bindings to communicate beween threads. But really, use a queue or a mailbox or something higher level than a shared variable for signalling.
rumbler31 has joined #lisp
<shka>
lparallel has queue
<shka>
cross platform, ok performance
<shka>
use it, it is good
FreeBirdLjj has quit [Ping timeout: 260 seconds]
<jasom>
shka: I'm well aware. I use queues of promises to ensure that I can collect the work of decompressing chunks of data in order to the output stream
emaczen has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<shka>
jasom: i thought so ;-)
<lisp_guest>
jasom: when you said "does what you would expect", you were thinking of that it creates a closure and that every thread will have x bound to the same object, right?
<jasom>
lisp_guest: correct. The only thing that matters for lexical bindings is where it is in the source code.
<lisp_guest>
yup
<jasom>
from the latin for "text"
Ven`` has quit [Read error: Connection reset by peer]
<jasom>
which comes from Greek apparently
Ven`` has joined #lisp
smurfrobot has joined #lisp
<lisp_guest>
does anyone know why i'm getting this error when trying to use SSL with Drakma (GET-ing an https url)
<lisp_guest>
The alien function "CRYPTO_num_locks" is undefined.
<lisp_guest>
[Condition of type SB-KERNEL::UNDEFINED-ALIEN-FUNCTION-ERROR]
<jasom>
lisp_guest: sounds like it needs to load an external library
<jasom>
ah, it's apparently been deprecated in openssl
<jasom>
perhaps it got removed? Try forcing it to load an older version of openssl.
<lisp_guest>
is that an option within drakma or?
<jasom>
it will probably involve changing the code (M-. is your friend)
<jasom>
I don't use drakma, so can't help you there :(
<jasom>
lisp_guest: you can also check if there have been any updates to drakma since the version you have installed
<lisp_guest>
hm i guess. i'm only getting into doing HTTP with CL and have seen that drakma is what most poeple use
<lisp_guest>
is there something else you would recommend?
cmatei has quit [Ping timeout: 268 seconds]
cmatei has joined #lisp
<jasom>
My http on CL is all server-side, I don't know that I've ever made an HTTP request from CL.
<jasom>
apparently just installing the right version of openssl works
<lisp_guest>
yeah, hah, i'll try that now
<lisp_guest>
how can i check which version of a package i have through quicklisp?
earl-ducaine has quit [Remote host closed the connection]
<jasom>
lisp_guest: I usually just M-. and then see the name of the directory (ql puts the version string in the pathname of the source)
earl-ducaine has joined #lisp
<lisp_guest>
jasom: what's M-. for you? dired?
<jasom>
lisp_guest: "jump to definition" in slime
<lisp_guest>
oh, and then you inspect the dir name, got it
<lisp_guest>
huh, but cl+ssl has this in its ASDF file, "(defsystem :openssl-1.1.0 ...)"
Kaisyu has quit [Quit: Connection closed for inactivity]
eudoxia has joined #lisp
<jasom>
well I would just check which openssl packages are available and ensure they are installed...
<jasom>
a lot of foreign library definitions are ... not great defaults...
<jasom>
This is largely due to DLLs being inherently broken, but still...
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<lisp_guest>
i have version OpenSSL 1.1.0 installed though. not sure why i would have to downgrade when the CL+SSL package i have seems to use OpenSSL 1.1.0
<lisp_guest>
hah wow, changing my libssl.so symlink to version 1.0 instead (which i also have installed) fixes it
<lisp_guest>
why the heck does it advertise as using 1.1.0 then
brendyn has quit [Ping timeout: 268 seconds]
attila_lendvai has quit [Quit: Leaving.]
<lisp_guest>
but now i might break other stuff on my pc that relies on 1.1.0
<lisp_guest>
ugh
<Bicyclidine>
i think the cl+ssl system doesn't use the 1.1.0 system.
yeticry has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
tcr has quit [Ping timeout: 268 seconds]
damke has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
yeticry has joined #lisp
smurfrobot has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 246 seconds]
<jasom>
If you edit the library search path to load a more version-qualified openssl, it should work and you can undo the link change. Submit a patch upstream as well, reporting which distro you are using.
ck_ has quit [Ping timeout: 248 seconds]
ck_ has joined #lisp
eudoxia has quit [Quit: Leaving]
cmatei has quit [Ping timeout: 240 seconds]
cmatei has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<lisp_guest>
jasom: i'm very new to lisp (and especially system/package management). where exactly is this library search path?
<jasom>
lisp_guest: look for define foreign library
<lisp_guest>
ok. i just opened up ffi-1.1.0.lisp from cl+ssl btw, they only define 2 new functions which were added
<lisp_guest>
which makes sense i guess, the real issue is in loading version 1.1.0 when 1.0 is expected by drakma
FreeBirdLjj has joined #lisp
<lisp_guest>
jasom: found it, nice :-)
<jasom>
my guess is that early versions of 1.1 deprecated, but did not remove the function, so it "worked on the developers machine at the time"
<jasom>
but that's just a supposition. either way it needs to be fixed...
<lisp_guest>
looks like my version is "1.0.2m", while the closest one in cl+ssl is "1.0.2", i.e. without the "m"
<lisp_guest>
let's see if it works
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<lisp_guest>
jasom: does doing (ql:quickload '#:cl+ssl) reload the system if i changed the file?
brendyn has joined #lisp
<jasom>
lisp_guest: I don't know; (asdf:load-system "cl+ssl") definitely wil reload the system, but it may or may not force reloading of the library depending on how cl+ssl defined its dependencies
<lisp_guest>
ah, i see. i just restarted the whole interpreter
<lisp_guest>
seems to work!
attila_lendvai has quit [Quit: Leaving.]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
FreeBirdLjj has joined #lisp
attila_lendvai has quit [Ping timeout: 260 seconds]
_whitelogger_ has joined #lisp
bmgxc9 has joined #lisp
greaser|q has joined #lisp
aindilis has joined #lisp
mrSpec has joined #lisp
_whitelogger has quit [Remote host closed the connection]
xantoz has joined #lisp
mrSpec is now known as Guest20567
nikivi has joined #lisp
zaquest has joined #lisp
sigjuice has joined #lisp
raydeejay has joined #lisp
larme has joined #lisp
hexfive has joined #lisp
Nikotiini has joined #lisp
sukaeto has joined #lisp
butterthebuddha has joined #lisp
jack_rabbit has joined #lisp
brendyn has joined #lisp
ramus has joined #lisp
xuxuru has joined #lisp
jsnell has joined #lisp
jack_rabbit has quit [Max SendQ exceeded]
jack_rabbit has joined #lisp
smurfrobot has joined #lisp
FreeBirdLjj has joined #lisp
aoh has joined #lisp
king_idiot has joined #lisp
xrash has joined #lisp
<lisp_guest>
jasom: made a pull request :-)
isoraqathedh has quit [*.net *.split]
_osune has quit [*.net *.split]
_osune has joined #lisp
isoraqathedh has joined #lisp
vlatkoB has quit [Remote host closed the connection]
butterthebuddha has quit [Ping timeout: 260 seconds]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
<alandipert>
is it possible to specify which "version" of quicklisp to use when resolving packages? i understand that the set of packages available on quicklisp are versioned together, and that this set changes over time. i am interested in specifying former versions in code so i can know that the code will continue to work the same way even if packages it pull
<alandipert>
ed from quicklisp change
<jasom>
alandipert: yes, there is a blog article on how to do so
butterthebuddha has joined #lisp
<alandipert>
jasom thanks, found it
jmercouris has joined #lisp
heurist` is now known as heurist
CrazyEddy has joined #lisp
FreeBirdLjj has joined #lisp
Guest20567 has joined #lisp
Guest20567 has quit [Changing host]
fikka has joined #lisp
Guest20567 has left #lisp ["Leaving"]
KZiemian has joined #lisp
Cymew has joined #lisp
<KZiemian>
hello world
FreeBirdLjj has quit [Ping timeout: 255 seconds]
<KZiemian>
I have a question
<shka>
ask it
mrSpec` has joined #lisp
<KZiemian>
in Practical Common Lisp
<KZiemian>
in chapter on conditions and handlers
<KZiemian>
it said that
<KZiemian>
that errors are not descend of standard-object
<KZiemian>
from historical reason
<shka>
yup
<KZiemian>
and some method like slot-initialize
<KZiemian>
don't work on them
<shka>
yes
<KZiemian>
I just wonder
<shka>
that's right
<KZiemian>
making errors being subclass of standard-object can make programs esier?
<KZiemian>
becuse it is lokk
<jasom>
they are objects, just not necessarily standard-object
<KZiemian>
in CL everything is object with common root T
smurfrobot has quit [Remote host closed the connection]
<shka>
it is not about superclass
fikka has quit [Ping timeout: 248 seconds]
<pjb>
They may be subclasses of standard-object. But since they are not in all implementations, you cannot depend on that.
Cymew has quit [Ping timeout: 240 seconds]
<jmercouris>
Is there a way to make M-q indent with spaces only? Is there an advantage to doing so? (please note, I am not trying to start a tabs vs spaces flame war)
<KZiemian>
pbj: you are right PCL write about it somewhere
<pjb>
Note: in Abcl, ccl, clisp, ecl, ERROR is a subclass of STANDARD-OBJECTS ; in sbcl not.
<shka>
jmercouris: why not define spaces globally in whole emacs?
cpape` has quit [Ping timeout: 240 seconds]
<pjb>
jmercouris: sure. Just configure emacs to use spaces instead of tabs. There are ton of howto pages on the subject.
<KZiemian>
pbj: I think that standard say that they shouldnt be subclass of STANDARD-OBJECT
<jasom>
jmercouris: it's not the default, which means it's not the majority, but other than that it's fine. I prefer it...
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<KZiemian>
pbj: I just thinking which way is better or they more or less equal?
<KZiemian>
pbj: I normaly work in SBCL
<Bicyclidine>
condition types being fully integrated with clos would be nice.
<pjb>
For you as a CL programmer, ther eis no better way, you must consider that conditions are not standard-object.
<KZiemian>
pbj: but for the working on CLUS I started to use CCL
<pjb>
For you as a CL implementer, you can do however you prefer.
<jasom>
KZiemian: yes it would be better, but it is what it is
<Bicyclidine>
jmercouris: indenting with spaces is fine.
Baggers has joined #lisp
<pjb>
If you're a CL implementer, I would say it is easier to just define conditions with defclass.
<pjb>
Just like structures.
xuxuru has quit [Remote host closed the connection]
<shka>
good night
<jasom>
CL is necessarily imperfect; this particular imperfection has rarely affected me
<pjb>
KZiemian: But as a CL implementer you may want to provide more speed, or consider other constraints when creating and processing conditions, which may motivate you to implement them differently.
<Bicyclidine>
it's probably also not necessary :p
xuxuru has joined #lisp
<jmercouris>
jasom: Ok, then, sounds good
<jmercouris>
Bicyclidine: Thank you for your opinion, I'll update my emacs config then
<pjb>
KZiemian: are you an implementer?
<pjb>
KZiemian: are you writing a new implementation?
kokonaisluku has joined #lisp
<KZiemian>
pbj: no, at least not now :)
fikka has joined #lisp
<KZiemian>
pbj: I just try to learn condition system
<pjb>
Then conditions are not subclasses of standard-object.
<KZiemian>
pbj: and that solution look unnatural to me
<Bicyclidine>
i can't think of any constraints on conditions that would really be helpful to an implementer
<pjb>
Bicyclidine: OUT-OF-MEMORY UNIX-SIGNAL
<pjb>
Bicyclidine: again, you may want to provide speed.
<KZiemian>
pbj: I just wonder is my feeling right or not
<pjb>
Bicyclidine: just have a look at sbcl.
<KZiemian>
pbj: now I working just on CLUS
<KZiemian>
pbj: and have enough question about it
<KZiemian>
pbj: bad words, not question but rather riddels to solve
<Bicyclidine>
in sbcl conditions are "slot-objects", which standard objects also are. that class provides most of the guts, like the initialize methods and shit
<KZiemian>
my true problem now is that
Xal has quit [Ping timeout: 260 seconds]
<KZiemian>
M
FreeBirdLjj has joined #lisp
<KZiemian>
I should take CLHS page with GENSYM
alfasardine has joined #lisp
<KZiemian>
and write ccldoc code to transform it in some nice webpage
<KZiemian>
I now more or less can write ccldoc file that make html of that page
<KZiemian>
but man, that page looks ugly
Xal has joined #lisp
<KZiemian>
one thing, my knowledge of ccldoc is medicore
<KZiemian>
or even lower
shka has quit [Ping timeout: 250 seconds]
<jasom>
KZiemian: note that it is technically illegal to work from the CLHS, you should work from the TeX sources of the draft specification...
<jasom>
CLHS has copyright owned by lispworks
FreeBirdLjj has quit [Ping timeout: 255 seconds]
EvW has joined #lisp
alfasardine has quit [Quit: Leaving]
xuxuru has quit [Quit: xuxuru]
ryanbw has quit [Ping timeout: 248 seconds]
<jmercouris>
Still waiting on that ultrapsec...
smurfrobot has joined #lisp
<jmercouris>
s/ultrapsec/ultrapsec
<jmercouris>
damnit, I think I might have dyslexia
<KZiemian>
jasom: ohh, yes
<KZiemian>
jasom
<KZiemian>
jasom: I forgot about this discussion
<KZiemian>
jasom: to much legal term to me
<KZiemian>
jasom: I should go to the draft specyfication or to CLUS resources
warweasle has quit [Quit: bye]
FreeBirdLjj has joined #lisp
<KZiemian>
jmercouris: I do what I can do end my part in this
<KZiemian>
jmercouris: now I try to learn enough ccldoc to rewrite CLUS page in that
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<KZiemian>
jmercouris: but after that my knowledge will be not suffiecent to make progres alone
varjag has joined #lisp
<KZiemian>
jmercouris: bigger discussion will be needed
mishoo has quit [Ping timeout: 260 seconds]
<jmercouris>
KZiemian: Are you the project leader? Do you need someone to edit stuff? any ways I can tangibly contribute?
orivej has quit [Ping timeout: 268 seconds]
epony has joined #lisp
<KZiemian>
jmercouris: project leader is phoe, but in some strange twist of fate, I think that probing ccldoc was left to me as subproject
<KZiemian>
jmercouris: we and phoe will neet at monday 18 and after that I should now more about that
<jmercouris>
Ah yes, I remember that now
<jmercouris>
KZiemian: Which time zone? UTC?
<jmercouris>
Ah, you are saying Monday the 18th, not at 18:00, got it! Sorry for the confusion
<KZiemian>
jmercouris: no problem, this was my mistake
<KZiemian>
jmercouris: current state of CLUS, at least my part
<KZiemian>
jmercouris: is to write ccldoc that generate one page that looks like that of CLHS
<KZiemian>
jmercouris: what I can do to this moment you can find here
<KZiemian>
jmercouris: how I say, I can make html page, but it looks ugly
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<KZiemian>
jmercouris: I mean html page generated by ccldoc
<KZiemian>
jmercouris: this is my part and don't know why we decided on ccldoc, not why we do next
<KZiemian>
jmercouris: I hope next monday phoe tell me more about it
<jmercouris>
I see, I'm sure the HTML is fine, it can always be remedied with CSS
<KZiemian>
jmercouris: this is one of my problems, I can see only part of project, but I try to make my part as good as I can
<jmercouris>
It's unfortunate that I don't speak polish, otherwise I would read what you've done :D
<jmercouris>
Looking at the HTML, it looks okay, there is indent a lot of work that could be done on it though
bmgxc9 has quit [Remote host closed the connection]
<jmercouris>
Mostly indentation and some spaces throughout, but the CSS will make it look fine, so it should be okay
smurfrobot has quit [Remote host closed the connection]
<KZiemian>
jmercouris: I know that laguage is big problem, but until I understand ccldoc I will write in polish, because that is much faster to me and now I must note a lot
<KZiemian>
jmercouris: many of this things will became probably irrevelant when we understand what is going on
kokonaisluku has quit [Quit: ChatZilla 0.9.93 [Firefox 52.5.1/20171205141522]]
<KZiemian>
jmercouris: but now better note everything that I see
Ven`` has quit [Ping timeout: 248 seconds]
<jasom>
Is this well defined: (defconstant +foo+ 3) #.+foo+
<Bicyclidine>
no. defconstant doesn't have to establish a binding in the compiler.
Achylles has joined #lisp
murii has quit [Quit: WeeChat 1.4]
<KZiemian>
jmercouris: one problem of CLUS is that, that I take a break after ending last stage
Ven`` has joined #lisp
<KZiemian>
jmercouris: I just need it, to much checking diff on my head at once
<KZiemian>
jmercouris: I cameback two weeks ago
<KZiemian>
jmercouris: I can't catch any preson from it
DeadTrickster has joined #lisp
<KZiemian>
jmercouris: phoe is exeption, but it not is for him to find time now
<KZiemian>
jmercouris: so I grab roadmap and start try to do point 1A: ccldoc
<KZiemian>
jmercouris: you can try to catch him ask what need to be done in CLUS
<jmercouris>
If I see him posting online I'll ask him
<jmercouris>
he is polish as well right? so he is on polish time zone?
<KZiemian>
jmercouris: yes he is polish, so probably he is on polish time zone
<KZiemian>
jmercouris: at monday he will definietly be in Poland
stara has joined #lisp
<KZiemian>
jmercouris: thank you for questions, I will try not forget to tell phoe about them
<KZiemian>
jmercouris: I must go in next 5-10 minuts, so if you want ask about somthing now is the time
<jmercouris>
I think I'll wait to see what you guys talk about on Monday, for now I think we've covered all the bases, thanks!
DeadTrickster has quit [Read error: Connection reset by peer]
<KZiemian>
jmercouris: thanks for good questions :)
<KZiemian>
see you
DeadTrickster has joined #lisp
KZiemian has quit [Quit: Page closed]
Ven`` has quit [Ping timeout: 256 seconds]
nalkri` is now known as nalkri
<jasom>
any suggestions for improving numeric performance on ccl? I'm seeing it currently ~10x slower than sbcl right now
pjb has quit [Read error: Connection reset by peer]
Tobbi has joined #lisp
pjb has joined #lisp
Ven`` has joined #lisp
<foom>
jasom: I think if you tell it the exact types of inputs and outputs to every math call it will compile it efficiently. E.g. (the fixnum (+ (the fixnum a) (the fixnum b)))
Ven`` has quit [Ping timeout: 248 seconds]
papachan has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
nalkri has quit [Ping timeout: 248 seconds]
jfb4 has quit [Ping timeout: 260 seconds]
<alandipert>
i see #'(lambda () ...) in CLHS example code, is there a reason for the #' with the inline lambda?
jfb4 has joined #lisp
<Shinmera>
If I recall it used to be necessary. Now that it isn't, some people just prefer it that way.
neoncontrails has joined #lisp
Ven`` has joined #lisp
raphaelss has quit [Ping timeout: 260 seconds]
<pjb>
alandipert: there's no good reason for #'(lambda
<pjb>
alandipert: I can find only bad reasons for it.
<jasom>
alandipert: the LAMBDA macro expands to #'(LAMBDA ...)
<pjb>
alandipert: lambda is a macro that expands to (function (lambda …)).
<jasom>
so it's redundant
FreeBirdLjj has joined #lisp
<pjb>
alandipert: so either you're in code position and the macro will do the right thing, or you're in data position, and writing #'(lambda will introduce the (function (lambda …)) sexp which is not evaluated, so probably not what you want anyways.
orivej has joined #lisp
<pjb>
alandipert: furthermore, lambda may be not cl:lambda (if it's shadowed). So writing #'(lambda … may expand to (CL:FUNCTION (NOT-CL:LAMBDA ...)) which is not conforming!
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<pjb>
alandipert: while NOT-CL:LAMBDA may be a macro that do what it needs to do. Adding #' in front prevents it.
wxie has joined #lisp
Kundry_Wag has joined #lisp
<alandipert>
thanks all, makes sense
<pjb>
(now of course, if you take the pain to shadow lambda you should also shadow function, and override #' too for consistency…)
bmgxc9 has joined #lisp
cpape has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
FreeBirdLjj has quit [Ping timeout: 256 seconds]
Karl_Dscc has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
dyelar has quit [Quit: Leaving.]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
Jesin has quit [Quit: Leaving]
raphaelss has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]