ayuce has quit [Read error: Connection reset by peer]
Lord_of_Life_ is now known as Lord_of_Life
gko has quit [Ping timeout: 246 seconds]
chewzerita has quit [Ping timeout: 246 seconds]
Achylles has joined #lisp
wxie has quit [Read error: Connection reset by peer]
Achylles has quit [Quit: Leaving]
orivej_ has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
efm_ has joined #lisp
benjamin1 has joined #lisp
wxie has joined #lisp
wsinatra has joined #lisp
marusich has joined #lisp
benjamin1 has quit [Ping timeout: 260 seconds]
wsinatra has quit [Quit: WeeChat 2.8]
bitmapper has quit [Ping timeout: 256 seconds]
efm_ has quit [Quit: Konversation terminated!]
wxie has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
Bourne has joined #lisp
benjamin1 has joined #lisp
refpga has quit [Ping timeout: 240 seconds]
bhartrihari has left #lisp [#lisp]
gaqwas has quit [Ping timeout: 256 seconds]
gaqwas has joined #lisp
gigetoo has joined #lisp
SGASAU has joined #lisp
benjamin1 has quit [Ping timeout: 272 seconds]
pjb has quit [Ping timeout: 272 seconds]
refpga has joined #lisp
benjamin1 has joined #lisp
_paul0 has joined #lisp
paul0 has quit [Ping timeout: 265 seconds]
dmiles has joined #lisp
<beach>
Good morning everyone!
zaquest has joined #lisp
Oladon has joined #lisp
benjamin1 has quit [Ping timeout: 244 seconds]
Balooga_ has joined #lisp
Balooga_ has quit [Client Quit]
anticrisis has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
jfrancis has joined #lisp
notzmv has quit [Ping timeout: 272 seconds]
notzmv has joined #lisp
notzmv is now known as Guest43056
ahungry has joined #lisp
<White_Flame>
hey, beach. I read your sliding-gc paper a bit ago. I'm curious about how sizing the nursery to the total CPU cache size made sense in terms of threading & multicore
<White_Flame>
do the nursery compactions occur & run in each mutator thread when they need it while everything else runs concurrently, or is this still a single-threaded stop-the-world GC that can assume all the cache resources?
<moon-child>
I'm trying to write my own version of 'and'. Here's my first crack at it http://sprunge.us/G3Kc7r?cl
<White_Flame>
you can't APPLY a special form, only functions
<moon-child>
doesn't work, of course. But is there something I can do to 'parm' to see its contents other than (list ,@parm)
<White_Flame>
when looping over PARM, you could print the current parameter (at compile time) to show you what exactly it can see
<White_Flame>
sure, that could work. Macroexpand it to see if it makes some extra terminator clauses in there, although the compiler would hopefully optimize things out
notzmv- has joined #lisp
<White_Flame>
eg, at the terminator you might end up with an (IF T T NIL)
notzmv- is now known as notzmv
<moon-child>
ah - yep, you're right
<no-defun-allowed>
moon-child: Why the underscore in my_and, and the blank lines between the cases?
<moon-child>
1. no good reason. I haven't written lisp in a while, so I forgot how good kebabs were. 2. clarity
<no-defun-allowed>
In Common Lisp, AND is specified to return the last form if the others are true, so it is unnecessary to wrap the last form in a (if <test> t nil).
<no-defun-allowed>
Something beach told me, is that it's nicer to put the "base case" of a recursive function or macro at the start, so the body would be (if (null parm) t <handle non-null parm>)
<beach>
White_Flame: Each application thread runs a nursery collection as it needs it.
<no-defun-allowed>
(And, well, you will probably end up with a COND for the three cases: no forms, one form, and more than one form.)
<beach>
White_Flame: I make sure there are no pointers from the global heap to the nurseries, so each mutator thread can run its GC independently of the others.
<moon-child>
no-defun-allowed: right. (Actually, the reason I'm going through this exercise is I'm building my own lisp and my 'and' definition had some trouble. So, don't have cond yet)
<no-defun-allowed>
I would define COND before AND.
_paul0 has quit [Ping timeout: 272 seconds]
<beach>
moon-child: Also, page 13 of the LUV slides by Norvig and Pitman tells us not to use a default value as if it were a Boolean. Here, PARM is not a Boolean, but a list. So, that's another reason to follow the advice of no-defun-allowed, i.e. (if (null parm) ...)
<White_Flame>
beach: I'm just saying re the cache sizes, that for instance the L1+L2 sizes are a lot smaller than the total cache size of the CPU
<White_Flame>
so if the total CPU cache size is 4MB, and each thread has a 4MB nursery, they don't all get the cache effect
<beach>
White_Flame: I didn't take the cache size into consideration, but maybe I should.
* no-defun-allowed
expects an eight minute instrumental while compiling moon-child's Lisp implementation
<moon-child>
beach: haven't seen those slides. What's wrong with using a default value as a boolean?
<beach>
White_Flame: The size is based on how long a GC would take and it has to be short enough to handle applications such as sound processing.
<moon-child>
no-defun-allowed: you need and for variadic =, which came up earlier
paul0 has joined #lisp
<no-defun-allowed>
Good point.
<beach>
moon-child: Elementary maintainability. You need to inform the person reading your code as soon as possible whether it is a Boolean or a list or something else with a default value.
<White_Flame>
beach: right, and if how long it takes relies on it being fully in cache, then if there are other threads running, then it won't be fully in cache
pjb has quit [Ping timeout: 272 seconds]
<White_Flame>
(as multiple threads of discussion thrash beach cache ;) )
<no-defun-allowed>
COND can be implemented with only IF (and the expansion creating stuff like LIST, but "only IF"), no?
<moon-child>
beach: if you see the macro takes the param as &rest, you know right away it's a list
<beach>
moon-child: You expose your code for others to read, so I assume you want remarks on it. If you don't, I'll be quiet.
<beach>
White_Flame: Yeah, I should consider those issues at some point.
Bourne has quit [Read error: Connection reset by peer]
luckless has joined #lisp
<beach>
White_Flame: I don't know enough about multi-core architectures, so I don't know which cache is specific to a core and which one is not.
<White_Flame>
L1 & L2 tend to be per-core, while L3 is a shared pool
<White_Flame>
for instance, the big threadrippers have 256MB of L3, but 512KB of per-core L2
<beach>
So then, ideally, the nursery should not be larger than L1+L2.
<White_Flame>
and each core's resources is split between 2 threads
<beach>
Hmm, yes, I see.
<beach>
Complicated.
<White_Flame>
however, including L3 in the pool, you can just divide that by the thread count and get some other estimate, too
<beach>
I understand.
sdumi has quit [Ping timeout: 246 seconds]
sdumi has joined #lisp
<beach>
White_Flame: I think what is going to have the most impact on performance is the parallel and concurrent global collector.
<beach>
I can assign all the idle cores to it. :)
<White_Flame>
yep. (if there are any ;) )
<beach>
Otherwise, I'll have to assign some of them anyway.
<solrize>
makes me want even more to mess with purescript
* no-defun-allowed
wonders how PureScript relates to Emacs Lisp and/or Common Lisp.
<solrize>
that gccemacs page mentions that gccemacs lisp supports TCO, so it can be a reasonable backend to purescript
<solrize>
although maybe it doesn't even need TCO for that
<phoe>
oooh! it's the ELS presentation guy
<no-defun-allowed>
So do SBCL, Clozure, CLISP, and approximately every Scheme compiler, but those implement sensible programming languages already.
<solrize>
clisp doesn't implement TCO unless you explicitly run the compiler
shka_ has quit [Ping timeout: 256 seconds]
<solrize>
every (not approximately every) scheme does it because the scheme definition requires it
<no-defun-allowed>
Loading a system with ASDF will COMPILE-FILE files (I think?) so that isn't a problem.
<solrize>
but, i don't know whether javascript does it, and JS is the main backend for PS
<solrize>
hmm i haven't been using asdf
<solrize>
i'll look into it
<luis>
solrize: "explicitly running the compiler" makes it sound like that's uncommon or difficult. It's neither!
<solrize>
it's more cruft
<phoe>
lispers: haha #'compile go #<LAMBDA ...> NIL NIL
* phoe
hides
<solrize>
bah
<solrize>
if it was reliable and automatic they could just write it into the language spec and get rid of LOOP
sdumi has quit [Ping timeout: 265 seconds]
orivej_ has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
<no-defun-allowed>
Yeah, nah.
<no-defun-allowed>
Extended LOOP is much easier to write than the equivalent in DO, simple LOOP or recursion, when applicable.
karlosz has quit [Quit: karlosz]
pmden has joined #lisp
gxt has joined #lisp
<solrize>
shrug i've never felt i wanted it but who knows
<beach>
LOOP you mean?
<beach>
If so: Wow!
<beach>
And we should certainly not get rid of it, since it does much more than just iterate.
<beach>
But I guess if you have never used it, you wouldn't know.
<splittist>
And elegantly constructed DO is a wonderful thing. But sometimes LOOP is the clearest way to present your thinking to yourself, the compiler and future readers of the code.
<luis>
splittist: I hate DO for some reason. :-)
<solrize>
i've seen some pretty horrid examples though one can write horrid examples of anything
<solrize>
there's a famous rant about LOOP by i think it may have been weinreb
<luis>
solrize: using a Lisp compiler to compile Lisp code is cruft? I'm confused.
<splittist>
luis: I do find I can fit the details of DO or LOOP in my brain, but not both at the same time.
<solrize>
having compiled code implement TCO while interpreted code doesn't is cruft
<no-defun-allowed>
solrize: Please show us on the REPL where (loop for x in list when (plusp x) minimize x) hurt you.
<phoe>
it's up to the implementations to implement TCO, the standard says nothing about that
<solrize>
what does that even do?
<solrize>
phoe, right, if the standard said TCO was required then much cruft could go away
benjamin1 has joined #lisp
<phoe>
solrize: ...are you seriously complaining about LOOP without understanding LOOP
<no-defun-allowed>
That would return the smallest positive number in LIST.
<no-defun-allowed>
Yeah, no, LOOP and imperative algorithms wouldn't magically disappear if you had tail call elimination.
<solrize>
(apply #'min (filter #'plusp x)) ?
<solrize>
or rather reduce
<no-defun-allowed>
That conses up an additional list in the middle.
<luis>
solrize: it's nice that Lisp compilers let you turn the O in TCO off, since it's a speed/space vs debug trade-off.
<solrize>
no-defun-allowed, that's why optimizing compilers were invented ;)
<phoe>
if you want to prove something, then yes, iteration is fully equivalent to filtering+application+reduction
<no-defun-allowed>
You would either want deforestation in the compiler, or something like SERIES which...does deforestation. Well, you would want deforestation then.
<phoe>
and Lisp is a multi-paradigm language, which is why we actually have both in the standard
<luis>
loop's great. reduce's great. It's all good. Except DO. DO is evil. :)
<solrize>
lisp is imperative; if it were multi-paradigm then TCO would be in the standard ;)
toorevitimirp has joined #lisp
<solrize>
being able to turn it off for debugging makes some sense i guess
<solrize>
i will have to check how purescript deals with it
<solrize>
i mean whether it does CPS conversion in the PS compiler
<solrize>
haha
<no-defun-allowed>
Perhaps you should go to #c++, #python, and some other channels and ask how they claim to be multi-paradigm without tail calls.
<solrize>
do they claim that? maybe they are counting OO as a paradigm ;)
<no-defun-allowed>
And Common Lisp does not?
<solrize>
"more paradigms than you can shake a stick at"
<solrize>
i forgot about OO i'm used to thinking of it as a 1990s thing that didn't work out
<beach>
I find it strange for someone to have opinions about whether a feature that that someone does know should be included or not in the language.
SGASAU has quit [Remote host closed the connection]
<no-defun-allowed>
Have you even read the Wikipedia page on Common Lisp?
<solrize>
yeah some time back
<no-defun-allowed>
"Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms."
SGASAU has joined #lisp
Ethan_ has joined #lisp
<phoe>
are we now debating multi-paradigmness of Lisp and whether lack TCO is enough to call a language "imperative"
<phoe>
seriously
Ethan_ has quit [Read error: Connection reset by peer]
<no-defun-allowed>
Yes, we are. I think this is a veeeery fun and productive use of my time.
Ethan_ has joined #lisp
<solrize>
hehe.... well i've gotten snagged by it in clisp a few times
* phoe
gently opens the door to #lispcafe
<luis>
I got late into a meeting because of this discussion. Gah. :D
<solrize>
luis oops
<solrize>
wow i didn't know about lispcafe
<beach>
phoe: Apparently, yes. And we are apparently treating CLOS as similar to the feature of other object-oriented languages.
<solrize>
brb
SGASAU has quit [Remote host closed the connection]
<phoe>
solrize: now you do!
SGASAU has joined #lisp
FishByte has quit [Ping timeout: 260 seconds]
<solrize>
CLOS also seemed pretty horrible though i confess i liked flavors
<beach>
solrize: Please stop it.
<solrize>
i wrote a half-assed implementation of flavors in emacs lisp once
<beach>
solrize: Please don't have opinions about features you know nothing about.
<solrize>
i read the docs and looked at code examples and that was enough for me... i'm sure you could do the same about C++ or whatever
sdumi has joined #lisp
* phoe
very gently nudges solrize towards #lispcafe
<solrize>
ok ok
<beach>
It sounds like you would be better off using a different language, since LOOP and CLOS are two of the main features of Common Lisp.
<beach>
I mean, Common Lisp doesn't even require tail-call optimization. Sheesh!
SGASAU` has joined #lisp
<phoe>
paradoxically, pointless complaining about Lisp is off-topic on #lisp since it achieves nothing
<phoe>
#lispcafe is open for that
<phoe>
but #lisp is for actually getting some work done in Common Lisp, and complaining is the anti-thesis of getting work done
<solrize>
CL was CL before CLOS was a thing
<phoe>
unless, I guess, it's constructive in some way - but at that point it's not complaining anymore
<solrize>
CLtL1 doesn't say anything about clos
<phoe>
solrize: you are 100% correct and 0% relevant
<phoe>
this channel is about ANSI Common Lisp, a dialect which contains CLOS as an integral part of it
<no-defun-allowed>
And? CLOS is well integrated into CL (except for the condition system. We don't talk about the condition system).
<solrize>
hehe
<phoe>
> hehe
<solrize>
is clos in cltl2?
<phoe>
let me warn you once
* phoe
(warn 'solrize)
<no-defun-allowed>
It's okay phoe, the condition system can't bully you, the condition system isn't real.
sdumi has quit [Ping timeout: 258 seconds]
jmarciano has joined #lisp
<solrize>
i remember reading sonya keene's book about clos
SGASAU has quit [Ping timeout: 260 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
<splittist>
Soooo. What's everyone's favourite idiom for: given a list of item names, return the first item of that name to be found in a key-value store?
orivej has joined #lisp
<Josh_2>
a hash table?
<phoe>
first item of what name
<Josh_2>
or a alist/plist
<phoe>
we have '(foo bar baz), which name do you mean
<phoe>
the first name, or for each name we want to return a value
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
ayuce has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<splittist>
I have a list "foo" "bar" "baz". These are potential keys to a hash-table (not really, but it makes no difference). I want to return the value that corresponds to the first key in the list that is found in the table, or nil (nil not being a valid value).
<phoe>
so if there is no value for "foo" then you want to look for "bar"
<phoe>
and if "bar" has a value then you return it and do not look "baz" up
<phoe>
correct?
<splittist>
phoe: Yes.
<no-defun-allowed>
(loop for key in keys for present = (present-p key) when present return (retrieve-value-for key))
cosimone has quit [Quit: Quit.]
agam has quit [Ping timeout: 246 seconds]
<phoe>
no-defun-allowed: eww
<solrize>
gnite all
<splittist>
no-defun-allowed: and if present-p and retrieve-value-for are the same function?
<phoe>
oh, wait, it's present-p
* splittist
tries to remember how "IT" works in LOOP
<phoe>
you can get (values value presentp) from gethash
<no-defun-allowed>
phoe: Did I forget to shower or something?
<phoe>
no no, I misread
<phoe>
(loop for key in keys for (value presentp) = (gethash hash-table values) when presentp return value finally (return :nope))
FreeBirdLjj has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
What, you can do FOR (values ...) = form?
cosimone has joined #lisp
<phoe>
uhhh I forgot
<phoe>
(loop for key in keys for (value presentp) = (multiple-value-list (gethash hash-table values)) when presentp return value finally (return :nope))
<phoe>
there!
orivej_ has joined #lisp
<splittist>
(loop for key in keys when (gethash key dict) return it finally (return nil)) ?
<phoe>
splittist: ewwww
<phoe>
(that is the eww that I originally wanted to make)
<phoe>
what if the value is NIL
<phoe>
like, (setf (gethash x y) nil)
<phoe>
then gethash will return (values NIL T)
<jdz>
splittist: You don't really need the finally part.
<phoe>
^
<splittist>
"(nil not being a valid value)"
<splittist>
jdz: ah!
<phoe>
oh! in that case, it's fine
orivej has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 260 seconds]
<jdz>
splittist: If instead of GETHASH you have your own dictionary lookup function (as you have hinted), then maybe this is more clear (assuming the point of the exercise is not to get it working with LOOP in particular): (some #'predicate keys)
<jdz>
And #'predicate should have been #'lookup.
<jdz>
This does not look so nice if you also want to pass the container you're looking at.
notzmv has quit [Remote host closed the connection]
<splittist>
jdz: interesting. Thanks.
ljavorsk has quit [Remote host closed the connection]
scymtym has joined #lisp
ljavorsk has joined #lisp
gaqwas has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 258 seconds]
gxt has quit [Ping timeout: 240 seconds]
gaqwas has joined #lisp
orivej has joined #lisp
ayuce has joined #lisp
milanj has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
shangul has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
orivej has joined #lisp
gxt has joined #lisp
pjb has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
benjamin-l has quit [Quit: WeeChat 2.8]
pjb has joined #lisp
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
gxt has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
sz0 has joined #lisp
heisig has quit [Quit: Leaving]
pfdietz has joined #lisp
orivej has quit [Read error: Connection reset by peer]
orivej has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
igemnace has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ngqrl has joined #lisp
EvW has joined #lisp
wsinatra has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
whiteline has quit [Remote host closed the connection]
simplegauss has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
whiteline has joined #lisp
shangul has joined #lisp
agam has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
sdumi has joined #lisp
simplegauss has joined #lisp
bhartrihari has joined #lisp
pkrJones_ has quit [Quit: Leaving]
agam has quit [Ping timeout: 256 seconds]
EvW has quit [Ping timeout: 260 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<ralt>
how do I do a CHECK-TYPE on a list? (check-type foo (list string)) is what I'd want
<phoe>
ralt: (assert (every #'stringp list))
EvW has joined #lisp
<phoe>
otherwise (loop for cons on list do (check-type (car cons) string))
<phoe>
the latter will make the STORE-VALUE restart meaningful
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
<pfdietz>
There are no type combinators that iterate over lists (or other sequences). A richer type system including such things, with integration into SUBTYPEP and the compiler, would be an interesting extension to CL.
<beach>
Jim Newtons dissertation contains such a type.
<beach>
RTE I think it is called. For Regular Type Expression.
<beach>
You can give a regular-expression-like s-expression that matches the types of elements of a list.
<phoe>
beach: I think it's for a list of specified length though
<beach>
What makes you think that?
<phoe>
since type expansions in Lisp must terminate and `list` is `(or cons null)`
lottaquestions has quit [Quit: Konversation terminated!]
mibr has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 260 seconds]
whiteline has quit [Remote host closed the connection]
doesthiswork has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
rogersm has joined #lisp
wsinatra has quit [Ping timeout: 244 seconds]
pmden has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
<jmercouris>
why WOUDLN'T they?
<jmercouris>
would there be a performance benefit of not working left to right?
<phoe>
because '(and a b c) is equivalent to '(and b c a)
<jmercouris>
I know they are equivalent
<jmercouris>
but normally they work left to right
<phoe>
no
<phoe>
there's no "normally" here
<jmercouris>
so called "short circuiting"
<phoe>
the implementation may freely reorder these while performing
<jmercouris>
well, another thing I've read that is false...
<phoe>
...performing type optimizations
wsinatra has joined #lisp
<phoe>
this is not the macro AND
<Bike>
yes, i'm talking specifically about types.
<phoe>
this is the intersection operator from set theory
<phoe>
the type specifier AND
<jmercouris>
ah, OK
<Bike>
as a stupid example, if you do (and (satisfies foo) nil), this can be reduced to nil, and you can avoid calling FOO at all.
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
whiteline has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
pmden has joined #lisp
toorevitimirp has joined #lisp
<phoe>
jmercouris: while (and x y z) may refer both to the type specifier AND and the macro AND, '(and x y z) almost always refers to the type specifier due to the quote
<phoe>
it's slightly hard to generalize since some macros might also make use of that for purposes of macro writing, but that's an edge case that isn't really relevant for heuristics of reading the meaning of such Lisp code snippets
rgherdt has quit [Remote host closed the connection]
paul0 has quit [Quit: Leaving]
milanj has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
yonkunas has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
kbtr has quit [Remote host closed the connection]
orivej_ has quit [Ping timeout: 260 seconds]
ebrasca has joined #lisp
dddddd has joined #lisp
jmarciano has quit [Ping timeout: 256 seconds]
gko has joined #lisp
pjb has joined #lisp
<yottabyte>
hi all, asked this yesterday but I'll try to ask it again: how do I insert spaces into a uri for drakma? for example "curl --location --request GET 'https://postman-echo.com/get?foo1=hi%20hi';" reads the query parameter foo1 as "hi hi" in the response under "args" but if you run the same request through drakma, it'll read "hi%20hi"
<jmercouris>
phoe: acknowledged
<phoe>
yottabyte: sounds like a problem in PURI
<phoe>
which is the URI library that drakma uses
<jmercouris>
You can try quri instead
<jmercouris>
the APIs are quite similar
<jmercouris>
that would involve some work though in changing drakma...
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<jmercouris>
what about trying dexador?
<yottabyte>
haven't heard of it, I'll try it right now
<phoe>
it's not drakma's fault, it's a bug in puri which is drakma's dependency
<jmercouris>
PURI is nice, but has some issues
bitmapper has joined #lisp
<yottabyte>
do I email him?
<phoe>
yottabyte: yes
rippa has joined #lisp
agam has joined #lisp
sdumi has quit [Ping timeout: 265 seconds]
agam has quit [Ping timeout: 256 seconds]
sdumi has joined #lisp
<jmercouris>
what is this git.kpe.io server?
<jmercouris>
I'm assuming it is Kevin's personal git repositories?
<phoe>
yes, it seems so
sdumi has quit [Ping timeout: 256 seconds]
gaqwas has quit [Quit: Leaving]
cage_ has joined #lisp
notzmv has joined #lisp
notzmv is now known as Guest57069
Guest57069 is now known as zmv
zmv is now known as Guest74931
pjb has quit [Ping timeout: 252 seconds]
Guest74931 is now known as notzmv
gaqwas has joined #lisp
<phoe>
FYI, LispWorks has released LispWorks 7.1.2 Personal Edition.
<phoe>
;; still no package local nicknames though, grr
<bitmapper>
phoe: is there a 64bit version
<bitmapper>
THERE IS
Aurora_v_kosmose has quit [Remote host closed the connection]
<phoe>
it seems there is, yes
jprajzne has quit [Quit: Leaving.]
jw4 has quit [Quit: tot siens]
Aurora_v_kosmose has joined #lisp
jw4 has joined #lisp
sdumi has joined #lisp
quasi25 has joined #lisp
jonatack has quit [Quit: jonatack]
<quasi25>
greetings folks! visiting after years ... perhaps even a decade !
<beach>
Hello quasi25. Welcome back.
<phoe>
quasi25: hello, how are things
orivej has joined #lisp
<splittist>
quasi25: we kept the standard the same for you
<quasi25>
hahaha.
<phoe>
not for long™
<quasi25>
lockeddown. Compiled the latest SBCL for fun.
gko has quit [Ping timeout: 256 seconds]
<quasi25>
darn .. I forgot how to use IRC
__jrjsmrtn__ has joined #lisp
agam has joined #lisp
_jrjsmrtn has quit [Ping timeout: 264 seconds]
<quasi25>
thanks phoe
<phoe>
quasi25: hm? what do you mean?
<phoe>
I referred to splittist comment
<quasi25>
haha.. I was just trying to see how to tag a user .... so tried your nic. I had forgotten. It's simply use the nick
<quasi25>
I feel so old
_quasi has joined #lisp
amerlyq has quit [Quit: amerlyq]
<_quasi>
woot! Joined via ERC :-)
quasi25 has left #lisp [#lisp]
<phoe>
not that old after all
pjb has joined #lisp
jonatack has joined #lisp
<_quasi>
:) heh.
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
<_quasi>
folks, I am need of a little bit of help. My old startup (~10 years old) tripr.in was done in Common Lisp. It's still running but no much much uses it and bit rot has happened (10 years is long). Having gotten the programing itch again (since I no more code in my day job) I am looking to get it to work well again. I setup everything and boom - CLSQL-MYSQL will not compile on the mac. I was using mysql and want to migrate to
<_quasi>
postgres. The CSLQL mailing list archives only go back up to 2015. Where to seek help?
afidegnum has quit [Quit: leaving]
<_quasi>
I got it compiled by fiddling with the Makefile. Now it wont load with "Unknown mysql client version '8.0.19"
<jackdaniel>
you probably have mariadb on the system
<jackdaniel>
afair it is enough to "make it accept" any version to have it working
<_quasi>
Lemonodor fame has eluded me for far too long!
Aurora_v_kosmose has joined #lisp
<_quasi>
jackdaniel I dont have mariadb on the system...
<pve>
_quasi: at least for postgresql you can use postmodern, I find it quite good
<Josh_2>
^
<jackdaniel>
aha
<phoe>
_quasi: what is your clsql version? are you using a recent one?
bebop has quit [Ping timeout: 272 seconds]
toorevitimirp has quit [Remote host closed the connection]
terpri has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
<_quasi>
phoe clsql-20160208; the one which comes with the latest quicklisp
<_quasi>
pve yes that's the reason I want to migrate from mysql to postgresql. Is there any other way to do it?
terpri has joined #lisp
<phoe>
pgloader!
<phoe>
(also written in lisp)
<_quasi>
phoe, yes yes Dimitri .. I have his book .. I had forgotten about pgloader
<pve>
_quasi: yes, dump the mysql db with the command line client, then use pgloader
<pve>
or do you need to massage the data before importing?
<phoe>
pve: AFAIK there's no need to dump, pgloader connects to mysql itself
<pve>
well that's sounds even better
shka_ has joined #lisp
<_quasi>
pve if it migrates directly I would be quite happy. I will then explore how to use postmodern on the existing data.
<pve>
_quasi: also look at s-sql from the same author I believe
<pve>
i don't use it for every query, but it can be convenient
<_quasi>
my friend Chaitanya has also written an ORM 'Zorm' on top of postmodern which I am looking to explore.
bhartrihari has joined #lisp
<_quasi>
pve s-sql.. sure.
<_quasi>
thank you good folks! I will be back, like Arnie, after I have explored this pgloader. Adios!
<phoe>
:D
<Josh_2>
_quasi: what was your startup for? I went to the site but not much info ¯\_(ツ)_/¯
rogersm has quit [Ping timeout: 240 seconds]
_quasi has quit [Ping timeout: 246 seconds]
frgo_ has quit []
holycow has quit [Quit: Lost terminal]
dxtr has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
<luis>
Some libraries like to mutate the *readtable*. They have the excuse that they predate named-readtables, fine. Is there a good point in ASDF to bind *readtable* to a readtable where these libraries can mutate all they want without messing with my readtable?
<jackdaniel>
that said, I'm not sure if people who depend on slightly broken libraries would be amused with a breakage, I think that was the reason for not merging it
<phoe>
correct
<phoe>
how do we proceed from here though, since we cannot even easily identify the breaking libraries at that point
<phoe>
can we?
<luis>
phoe: grep for set-dispatch-macro-character :) closure-common defines a few
pjb has joined #lisp
<phoe>
hm, we'd need to grep the whole quicklisp world for that.
<jackdaniel>
it isn't that big
<phoe>
pfdietz: I remember you working with something similar before, could you help us out?
<phoe>
jackdaniel: correct
<luis>
Babel (used to?) overwrite #\ (so sorry, that was early-20s-luis's idea!)
<phoe>
luis: #\Space you mean?
* jackdaniel
wonder if he should answer to each statement directed at him he agrees with with a word "correct"
<luis>
#\# #\\ I mean.
<jackdaniel>
wonders°
<phoe>
okay, point taken
<jackdaniel>
correct
<jackdaniel>
;>
sdumi has joined #lisp
Necktwi_ has joined #lisp
Necktwi has quit [Ping timeout: 258 seconds]
fanta1 has quit [Quit: fanta1]
akoana has joined #lisp
EvW has joined #lisp
aindilis has quit [Remote host closed the connection]
sdumi has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
ngqrl has quit [Quit: Connection closed for inactivity]
scymtym has quit [Ping timeout: 252 seconds]
rogersm has joined #lisp
rgherdt has joined #lisp
rogersm has quit [Ping timeout: 240 seconds]
doesthiswork has quit [Ping timeout: 258 seconds]
ldb has joined #lisp
<ldb>
ping
lavaflow has quit [Ping timeout: 256 seconds]
<Josh_2>
pong
<jackdaniel>
ash
doesthiswork has joined #lisp
lavaflow has joined #lisp
aindilis has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
scymtym has joined #lisp
emys has joined #lisp
Jesin has quit [Quit: Leaving]
Ethan__ has joined #lisp
Jesin has joined #lisp
Ethan__ has quit [Read error: Connection reset by peer]
bhartrihari has left #lisp ["Disconnected: closed"]
Ethan__ has joined #lisp
bhartrihari has joined #lisp
Ethan_ has quit [Ping timeout: 260 seconds]
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
theseb has joined #lisp
kpoeck has joined #lisp
ozzloy has quit [Ping timeout: 260 seconds]
ozzloy has joined #lisp
ozzloy has quit [Changing host]
ozzloy has joined #lisp
pjb has joined #lisp
sdumi has quit [Ping timeout: 256 seconds]
jprajzne has joined #lisp
orivej has joined #lisp
ym has quit [Quit: Leaving]
karlosz has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
duncan_ has joined #lisp
milanj_ has joined #lisp
milanj has quit [Read error: No route to host]
Jesin has quit [Quit: Leaving]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
milanj__ has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
milanj_ has quit [Ping timeout: 258 seconds]
Jesin has joined #lisp
[mark] has quit [Quit: Konversation terminated!]
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 260 seconds]
sauvin has quit [Remote host closed the connection]
<phoe>
luis: holy ouch
<phoe>
so that's the issue with the readtable...
pmden has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
EvW has joined #lisp
sdumi has joined #lisp
Bahman has joined #lisp
sdumi has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
terpri has quit [Remote host closed the connection]
bhartrihari has joined #lisp
terpri has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Bahman has quit [Quit: ave atque vale]
terpri has quit [Remote host closed the connection]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
terpri has joined #lisp
efm has joined #lisp
cranes has quit [Quit: Lost terminal]
cranes has joined #lisp
stentroad has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
flazh has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
vhost- has quit [Ping timeout: 244 seconds]
vhost- has joined #lisp
agam has quit [Read error: Connection reset by peer]
agam has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
rogersm has joined #lisp
agam has quit [Ping timeout: 272 seconds]
stentroad has quit [Ping timeout: 272 seconds]
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
toorevitimirp has quit [Ping timeout: 260 seconds]
marcoxa has quit [Quit: Good night.]
Inline has joined #lisp
agam has joined #lisp
ljavorsk has quit [Ping timeout: 258 seconds]
Cymew has quit [Ping timeout: 246 seconds]
rogersm has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
kpoeck has quit [Remote host closed the connection]
orivej has quit [Read error: Connection reset by peer]
orivej_ has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
anticrisis has joined #lisp
efm has quit [Quit: Konversation terminated!]
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
shka_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
orivej has joined #lisp
Balooga has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
<Josh_2>
Inline: couldn't you do half of that in a single loop?
orivej has quit [Ping timeout: 264 seconds]
orivej_ has joined #lisp
<Josh_2>
you are checking (first form) in a few cases, surely you could just use (case (first form) ..) and then just put them in a hashtable or a list etc
<Inline>
erm, i'm not optimizing early
<Bike>
why did you post this
<Josh_2>
even if you wanted to only extract one type, you don't really need all that code duplication. You could have one function that just collects lines that start with 'defmacro or 'defmethod and then define extract-macro-names extract-method-names etc with that function
<Josh_2>
instead of all the code duplication
<Inline>
welp, that's what i got working for now for extracting different stuff in my local mcclim dirs
<Josh_2>
The first four are the same function just with a different symbol in the (eq ..) form
<Inline>
i wanted to see what belongs to what explicitly i.e. clim/drei/esa
SGASAU` has quit [Remote host closed the connection]
<Inline>
hmmm
SGASAU` has joined #lisp
* phoe
sigh
<Inline>
i could join them like you say but then i have to also rename the toplevel definition to something like extract-spec (&key (g generic-function)....
<Inline>
extract-spec g would then give me the gfs extract-spec f would give the funs etc
<Inline>
hmmm, surely doable
<Josh_2>
(defun extract-spec (sym filename)) and then (defun extract-gf-names (filename) (extract-spec 'defgeneric filename))
<Inline>
jah ok
<Inline>
later on maybe
<Josh_2>
Same goes for the bottom functions that are all basically the same