<pl>
oh god. I know now why nobody could setup some flags on #lisp@freenode. Nobody has founder flag, except for a placeholder account created 8y ago
akoana has quit [Quit: leaving]
mood has quit [Ping timeout: 264 seconds]
hexology has quit [Quit: hex on you ...]
dlowe has joined #commonlisp
dlowe has quit [Remote host closed the connection]
Guest417 has quit [Ping timeout: 268 seconds]
Guest417 has joined #commonlisp
Colleen has quit [Read error: Connection reset by peer]
Colleen has joined #commonlisp
horar has quit [Quit: Client closed]
karlosz has quit [Quit: karlosz]
Guest417 has quit [Ping timeout: 268 seconds]
<beach>
Good morning everyone!
Guest417 has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life_ is now known as Lord_of_Life
azimut has joined #commonlisp
bilegeek has joined #commonlisp
raeda has quit [Remote host closed the connection]
hexology has joined #commonlisp
selwyn has joined #commonlisp
tzlm454 has joined #commonlisp
hendursaga has quit [Remote host closed the connection]
tzlm454 has quit [Remote host closed the connection]
hendursaga has joined #commonlisp
karlosz has joined #commonlisp
horar has joined #commonlisp
horar has quit [Quit: Client closed]
silasfox has joined #commonlisp
<loke[m]>
Hello beach
<loke[m]>
Can you see this message? Just want to know if the Libera<->Matrix bridge is working
<White_Flame>
obligatory "no"
<loke[m]>
White_Flame: thanks.
<beach>
Seems to be working.
<aeth>
how about this? does this work?[m]
<aeth>
oh, wait, matrix people wouldn't get the joke because they don't see the [m]s
casual_friday has quit [Quit: %bye%]
casual_friday has joined #commonlisp
* beach
didn't get the joke despite not being a matrix person.
domovod has joined #commonlisp
leeb has joined #commonlisp
shka has joined #commonlisp
Inline has quit [Quit: Leaving]
hexology has quit [Quit: hex on you ...]
hexology has joined #commonlisp
heisig has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
selwyn has joined #commonlisp
<loke[m]>
beach: don't worry. Even if you do get it, it's questionable whether it constitutes a joke :-)
<beach>
Whew!
<beach>
Thanks! :)
selwyn has quit [Remote host closed the connection]
selwyn has joined #commonlisp
crc has joined #commonlisp
bilegeek has quit [Quit: Leaving]
selwyn has quit [Read error: Connection reset by peer]
<hexology>
does anyone here have a nice example of a vim/neovim editing setup they'd be willing to share? i've been using vlime but i haven't configured it much, and i haven't tried slimv at all (although i am using the paredit plugin by the same author).
igemnace has joined #commonlisp
Cymew has joined #commonlisp
engblom has joined #commonlisp
<flip214>
hexology: I used slimv and am now on vlime. I use the long (slimv) keybindings. What are you looking for?
<hexology>
other people's ideas, i suppose. i find that it's a good way to learn.
<hexology>
you prefer vlime?
<hexology>
from what i recall, slimv requires a separate terminal window and maybe also tmux, which sounded somewhat annoying
<hexology>
i also feel like im not managing all the vlime windows effectively. it has a lot of options for setting default window positions and sizes, and i dont feel like im taking full advantage of it
cjb has quit [Quit: 👋]
<flip214>
hexology: well, yeah, my local git checkout also has some changes regarding window layout
pve has joined #commonlisp
rgherdt has joined #commonlisp
prite has joined #commonlisp
<susam>
Good morning!
<engblom>
Good morning susam!
<flip214>
hexology: I've got a key bound to store the current top-level form in a register and evaluate it, and another to evaluate the current form and replay the stored one
<flip214>
that means with one key I can store a test function, with another I can change a function and re-run the test at once
<hexology>
that's clever
Krystof has joined #commonlisp
pve has quit [Ping timeout: 268 seconds]
pve has joined #commonlisp
Lycurgus has joined #commonlisp
Th30n has joined #commonlisp
favonia has joined #commonlisp
bilegeek has joined #commonlisp
Oladon has quit [Quit: Leaving.]
hendursaga has quit [Ping timeout: 252 seconds]
hendursaga has joined #commonlisp
karlosz has quit [Ping timeout: 268 seconds]
karlosz has joined #commonlisp
heisig has quit [Quit: Leaving]
Guest417 has quit [Ping timeout: 268 seconds]
mindCrime has quit [Ping timeout: 268 seconds]
Guest417 has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
bilegeek has quit [Quit: Leaving]
leeb has quit [Quit: WeeChat 3.1]
igemnace has quit [Quit: WeeChat 3.1]
Th30n has quit [Ping timeout: 264 seconds]
Guest417 has quit [Quit: WeeChat 3.1]
karlosz has quit [Quit: karlosz]
jeosol has quit [Quit: Ping timeout (120 seconds)]
<gigo>
For programs that depend on current path, how do you write your code so that you can run it conveniently from shell as well as SLIME? Do you set *default-pathname-defaults* to the project top-level directory in Emacs everytime you work with the project?
<beach>
Use ASDF-relative pathnames.
<gigo>
thanks
<susam>
hexology: Very late to the discussion but Slimv requires one of (a) separate terminal window (satisfiable in a desktop environment) (b) GNU Screen (c) tmux. As long as one of these is present, it can launch Slimv automatically. If none of them is present, Slimv can be launched manually using sbcl --load /path/to/slimv/slime/start-swank.lisp. Yes, it can be annoying but easy to automate if one is going
<flip214>
I also used a separate xterm window for that
Th30n has joined #commonlisp
favonia has joined #commonlisp
kevingal has joined #commonlisp
random-nick has joined #commonlisp
silasfox has quit [Ping timeout: 268 seconds]
osp has joined #commonlisp
Nilby has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
jans has joined #commonlisp
<gigo>
anyone can help me and tell why the first macro produces the desired result (create a progn block that executes during evaluation) but the second macro does not produce the same result?
<beach>
gigo: What macros?
<gigo>
beach: https://bpa.st/OITA (sorry forgot to paste the paste url earlier)
<gigo>
The closing parens for defmacros look weird. please ignore that. still a beginner to lisp. need to get used to the lisp indentation style
<beach>
For one thing, the macro expansion is what the last form of the macro body returns, so if the last form is a FORMAT, it is what FORMAT returns.
yitzi has joined #commonlisp
<beach>
So the (push 'progn body) in the second macro has no effect.
<beach>
Its value is not used in any way.
<gigo>
so the macro expansion was expanding to nil. thanks for the help. need to practice more.
<beach>
A macro is nothing more than a function that transforms code.
<beach>
So, just like a function, a macro function returns the value of the last form in its body.
<beach>
It is highly unusual to print things in macro expanders, but you could do a (prog1 (push 'progn body) (format ...)) in the second macro.
<beach>
And, I am not sure what text editor you use, but the calls to a-block and b-block ought to have been indented differently since they have a &body parameter.
<beach>
Oh, wait, you are using &rest.
<beach>
You should be using &body instead in macros.
<gigo>
beach: thanks!
<beach>
Pleasure.
<dsk>
gigo: You can find out what your macro call expands into by calling MACROEXPAND-1 on it, e.g. (macroexpand-1 '(a-block foo bar))
Th30n has quit [Quit: WeeChat 3.1]
<beach>
dsk: Your nick is used to mean Dominique Strauss-Kahn here in France.
<dsk>
beach: I know :(
<beach>
OK, just making sure you do.
<dsk>
But I registered it first, so the joke's on that bastard.
<beach>
Fair enough.
<flip214>
dsk: before 1949
<flip214>
?
<dsk>
flip214: Well no, IRC wasn't invented until 1989, and I didn't get on it until a decade after that.
Bike has joined #commonlisp
<dsk>
Anyway, presumably lots of people have these initials.
Bike has quit [Client Quit]
Bike has joined #commonlisp
ircseeker has joined #commonlisp
Bike has quit [Client Quit]
Bike has joined #commonlisp
Bike has quit [Client Quit]
Bike has joined #commonlisp
Lycurgus has joined #commonlisp
cranium has joined #commonlisp
cammie has joined #commonlisp
Cymew has quit [Ping timeout: 268 seconds]
osp has quit [Quit: Leaving]
<gigo>
I have a list, say (defparameter a (list 1 2 3 4)). Is there a good way to push to the front of the list as well as append to the back of the list? (push 10 a) works fine. But what should I do for appending to the end of the list?
<Bike>
basically (append a (list 10))
<Bike>
if that sounds inefficient, it's because it is
<beach>
And you may want to change the value of the variable too, like (setf a (append a (list 10))).
favonia has quit [Quit: Ping timeout (120 seconds)]
<Bike>
well, (setf a (append a (list 10))), really, or (setf a (nconc a (list 10))) if you know a isn't constant data and isn't shared
<Bike>
yeah
Lord_of_Life has quit [Excess Flood]
favonia has joined #commonlisp
<beach>
gigo: But you should use earmuffs with special variables, so *a* rather than a.
Lord_of_Life has joined #commonlisp
<flip214>
gigo: if you have a (LOOP ...), there's COLLECT. (Similar with ITERATE)
Inline has joined #commonlisp
bhyde has joined #commonlisp
<pjb>
gigo: you're enroute for weeks of debugging!
<pjb>
gigo: use the earmuff convention!!!
_whitelogger has joined #commonlisp
<Bike>
you could write that with backquote
<jackdaniel>
macros are usually written with a backtick (instead of explicit consing)
<Bike>
`(progn (format t ...) ,@body (format t ...))
<jackdaniel>
also, since it is a decorator, you may want to return values from body (instead of returning nil - result of calling format)
<jackdaniel>
`(progn (format t ...) (multiple-value-prog1 (progn ,@body) (format t ...))
Lord_of_Life_ has joined #commonlisp
cranium has quit [Read error: Connection reset by peer]
random-nick has quit [Ping timeout: 268 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
Colleen has quit [Ping timeout: 268 seconds]
Colleen has joined #commonlisp
favonia has quit [Ping timeout: 268 seconds]
kevingal has quit [Ping timeout: 268 seconds]
<jackdaniel>
before header you may want to add ~& directive (it adds a new line only when the cursor is not at the beginning of the new line)
<jackdaniel>
(format t "~&----- header ~a -----~%")
Lycurgus has quit [Ping timeout: 268 seconds]
<jackdaniel>
a useful forward-compatible convention for "body macros" is to have one more argument after name called i.e options
<jackdaniel>
so you may customize the macro in the future
<pjb>
gigo: if you want to add in front and at the end of the list alternatively, and efficiently, you can keep a pointer to the first and last cons cells of the list.
<jackdaniel>
extending macros with only one non-body argument is also possible, i.e by coercing to list and destructuring it: (destructuring-bind (name &rest options) (ensure-list name-and-opts) ...)
* beach
keeps quiet in order to avoid newbie overload.
mindCrime has quit [Ping timeout: 252 seconds]
<gigo>
bhyde: why did you nested progn within prog1 within progn? Why can't it be just one progn with everything flat inside it?
<pjb>
that said, when you consider a macro as a code generator, using push to accumulate the subexpressions from the end is a valid option.
<pjb>
gigo: but you can create lists in order, using push, and nreverse at the end.
<bhyde>
prog1 assures the result of the body is returned, not the result of the last format
<pjb>
gigo: this is not less efficient than keeping track of the last cell.
<pjb>
and an unwind-protect might be in order.
<bhyde>
macro writing has a lot of tricks of the trade! jackdaniels suggestion to use multiple-value-prog1 is another example
<jackdaniel>
bhyde: using prog1 isn't a correct solution, you don't know how many values body returns
contrapunctus has left #commonlisp [#commonlisp]
<bhyde>
pjb’s suggestion of a unwind protect is yet another
<bhyde>
“correct” is all well and good the beginner may not enjoy the perfect example
<jackdaniel>
I'm sure that the beginner will not enjoy an incorrect example though
<jackdaniel>
(i.e no example is better than an incorrect one for the latter creates a bad habit)
pve has quit [*.net *.split]
Lycurgus has joined #commonlisp
contrapunctus has joined #commonlisp
pve has joined #commonlisp
<bhyde>
most learning involves passing thru a few phases of first understanding a simplified model of things. asking the beginner to understand it all before he can write any macros … i just can see that being a good approach
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
<bhyde>
can -> can’t
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
favonia has joined #commonlisp
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
Lycurgus has quit [Quit: Exeunt]
<jmercouris>
It isn’t a good approach
<phoe>
bhyde: "before he can write any macros" writing macros requires one to understand how they are utilized by the Lisp compiler, how to work on basic Lisp data structures i.e. conses and lists and symbols, how to use backquote, what are the most common pitfalls e.g. with variable capturing or evaluation order or multiple evaluation or side effects
<phoe>
it's a naturally complex (as in non-basic non-simple) topic, so don't expect any shortcuts in this matter.
<phoe>
and, yeah, one needs to know how to write pure and/or idempotent functions that accept Lisp data and return Lisp forms, because that's literally what macroexpander functions are.
<Nilby>
Maybe someone should write a SICP-like book for CL: "Learn CL the hard way" by writing a CL interpreter and compiler in CL.
<bhyde>
i guess some would argue you should begin by learning about &env, but not me. macros are delightful and to my mind in the top handful of features.
<Nilby>
I think I'm still learning the hard way, by pretty much only reading the standard and random code.
<Nilby>
Worse I had to un-learn maclisp and other crap-lisps.
<moon-child>
an idiom I see a lot is to repeatedly push onto a list, and then reverse it before returning. Why do this rather than maintain a pointer to the final cons of the list?
<phoe>
moon-child: nasty edge case with empty lists
<phoe>
as in, you can't set the CDR of NIL
<Bike>
so what you have to do is make an extra dummy cons that doesn't get returned
<moon-child>
then initialize with (list nil), and return the cdr of that
<Bike>
it's not that complicated, but it's a little annoying
<phoe>
sure, some people do that
<Bike>
if you macroexpand loop collect you'll see it probably doing that
<phoe>
but still, push + nreverse is not a huge performance bottleneck
<moon-child>
(not to mention, it's the sort of thing that could be easily dealt with with a macro)
<pjb>
moon-child: this is because both solutions are as efficient as the other.
<pjb>
moon-child: they perform exactly the same number of memory read and writes.
didi has joined #commonlisp
<moon-child>
yes, but push maintains better locality
<pjb>
moon-child: the only thing that changes, is the order. So with different caches, there may be differences, but when the technique was invented, there was no cache.
<moon-child>
s/push/push onto end/
<Nilby>
the final cons doesn't get you much
<pjb>
If locality matters in your program, you should consider using vectors too…
<pjb>
and specialized vectors at that…
<didi>
DEFSTRUCT defines a predicate for new types. Should I define similar ones when using DEFCLASS? They are handy at times.
<moon-child>
sure
cammie has quit [Ping timeout: 265 seconds]
<pjb>
(typep obj 'class) works too…
<phoe>
^
<moon-child>
didi: if you like
<pjb>
as wel as (type-of obj) and (class-of obj)
<didi>
Indeed. I define something like (defun namep (obj) (type obj 'class)).
<phoe>
I, for one, never really use the defstruct predicates
<phoe>
the reason being the existence of TYPEP
<didi>
phoe: ic
<didi>
Thank you.
<pjb>
predicates are convenient, but I object to the way they're used in scheme to characterize types, since they cannot give the type of objects for which you don't have a predicate. (and where do you find the list of all the predicates?)
<pjb>
So I prefer type-of or class-of.
* didi
nods
<phoe>
whereas class-of makes it impossible to use inheritance
<phoe>
which can be a feature or a bug, depending on your use case
<pjb>
Then you can derivate predicates, but it's a little useless. (defun foop (x) (typep x 'foo)) :-/
<pjb>
phoe: (defun foop (x) (subclassp (class-of x) 'foo)) too
<didi>
One handy use for predicates is to filter sequences of objects. (remove-if-not #'namep sequence).
<bhyde>
Nilby - I think that’s because the resulting code is so much easier to read. There are plenty of alternatives that are concise but no reall concensus about which one to use. So, for example, if your team is already using loop our can use it’s collect. If there not your code reviewers are likely to get cranky when you go first.
<Nilby>
bhyde: Yes, quite I agree. Also nreverse is potentially parallelizable like qsort.
<phoe>
pjb: c2mop:subclassp exists
<bhyde>
the push/nreverse trick is fun, but it has a the slight flaw of requring the reader of the code to bear in mind that this is going to be reversered before we’re done
<phoe>
Nilby: it's not really parallelizable for lists
<pjb>
phoe: right. I'm writing a CL implementation, so…
<phoe>
you need to traverse the first half of the list in order to reach the second one
<phoe>
so usually you can nreverse it along the way too
<phoe>
bhyde: it's sort of an idiom to push + nreverse so I assume that Lisp programmers with a bit of experience are actually going to be used to it
<pjb>
Note that loop can use push+nreverse if you don't name the resulting list.
<pjb>
But if you name it (and use it), it has to add to the tail.
<moon-child>
can it at least keep track of the tail? Or does it have to guard against your chopping off the list in the middle?
<didi>
Speaking of LOOP and it, I recently tried something like (loop for i until 10 when (oddp i) collect (+ it it)) and it didn't work. A bummer, but understandable.
<phoe>
ah yes, the famous anaphora issue
<phoe>
it is being collected, it just isn't what you think it is
<moon-child>
didi: it seems to work fine, if you replace until with below and it with i
<didi>
moon-child: I see, tho my exercise was about `it'.
<moon-child>
ahh haha
* moon-child
needs to read more clearly
<didi>
:-)
<bhyde>
it would be fun to convince somebody to write a translater between the various iteration packages: iterate, loop, series LOL
<moon-child>
probably not possible in a general sense
findiggle has quit [Remote host closed the connection]
<bhyde>
i think you could do one from loop to iterate (ignoring the versions of loop that let you extend it).
<bhyde>
iterate to loop would be hard, but for the common subsets it might not be too hard
ad_absurdum has joined #commonlisp
<bhyde>
it’s been way too long since I last felt I could write using series, it really makes you think different(tm) :)
ad-absurdum has quit [Ping timeout: 268 seconds]
waleee has joined #commonlisp
OlCe has quit [Ping timeout: 272 seconds]
didi has left #commonlisp [O bella ciao bella ciao bella ciao, ciao, ciao.]
prite has quit [Ping timeout: 268 seconds]
jcowan has joined #commonlisp
<jcowan>
A dirty little hack (from HAKMEM #163): what does this do?
<jcowan>
(SETQ X (PROG2 0 Y (SETQ Y X)))
<moon-child>
isn't that just the same as (setq y x)?
<jcowan>
No.
prite has joined #commonlisp
<Bike>
(rotatef x y)?
<Bike>
the prog2 0 is throwing me.
<mfiano>
That is pointless. No need for prog2
<jcowan>
Just so. The 0 could be any side-effect-free expression
v88m has joined #commonlisp
<mfiano>
(setq x (multiple-value-prog1 (values y (setq y x))))
<mfiano>
No macros.
<jcowan>
mfiano: I don't think you appreciate the notion of "hack value".
<mfiano>
Which is odd because a) there's potentially a variable behind that prog2, b) prog1 was available back then, no need to throw away code like with 0
<Bike>
the one that always confuses me is this one bit mit loop does in collection clauses
<Bike>
rplacd of setq or something
<Bike>
at one point i had a compiler bug that essentially removed the left to right evaluation order restriction, and pretty much everything worked fine, except for that
<mfiano>
I do see the value in it, but I didn't agree with the annotation "To exchange two variables in LISP without using a third variable"
<jcowan>
Scheme has always done without a fixed ordering, though not all compilers actually take advantage of this
<mfiano>
If you're using a macro to "get rid of" a variable, by that logic, anything could be written without variables
<mfiano>
Whereas in my version, it doesn't use a macro
<pjb>
jcowan: it's an unbound variable error?
<jcowan>
pjb: It assumes that x and y are bound to begin with
<Bike>
jcowan: yeah, i know. what i mean is just that very little actual CL code is dependent on that part of the semantics
<pjb>
Why prog2, when prog1 do: (let ((x 44) (y 33)) (SETQ X (PROG1 Y (SETQ Y X))) (values x y)) #| --> 33 ; 44 |#
<mfiano>
pjb: That's what I said, but still a macro hiding the variable
<pjb>
(let ((x 44) (y 33)) (psetf x y y x) (values x y)) #| --> 33 ; 44 |#
<Bike>
i mean whether there's a variable or not doesn't matter really
<jcowan>
I admit I don't understand why it uses prog2 unless for obfuscation. In any case, multiple values definitely did not exist yet, nor rotatef either.
<mfiano>
Bike: It does when Sussman's description is "without using one"
<Bike>
the implementation could implement multiple-value-prog1 as a macro, and even if it doesn't, it may be using extra storage at a lower level, if some kind of exchange instruction isn't available
<pjb>
Well with integers you can do (let ((x 33) (y 44)) (setf x (logxor x y) y (logxor x y) x (logxor x y)) (values x y)) #| --> 44 ; 33 |#
<Bike>
(or if the compiler isn't that smart)
<pjb>
then no need for a temp variable.
<jcowan>
logxor is pretty expensive on bignums
mindCrime has joined #commonlisp
jeosol has joined #commonlisp
didi has joined #commonlisp
<_death>
jcowan: I believe PROG2 pre-dated PROGN, so it may have been a special operator, while PROG1 was a macro
<jcowan>
That sounds plausible. There was some special reason for prog2, but I don't know what.
<didi>
Should DEFPACKAGE's IMPORT-FROM be able to import unexported symbols?
<didi>
I like to import symbols, but there are clashes with some. Nicknames help.
waleee has quit [Ping timeout: 264 seconds]
<phoe>
luis: depends on the clisp maintainers i guess
<loke[m]>
luis: I don't understand why they haven't made a new release. There have been some fixes on and off over the decades, but if you install it from a package, you're getting a 15 year old version
<loke[m]>
It's really bizarre
<loke[m]>
Even GCL has had newer releases than CLISP.
waleee has joined #commonlisp
<_death>
loke: I think they have some (easily fixable) NSIS bug that they want to get fixed before release.. maybe a pull request for that could somehow trigger a new release
<loke>
_death: for 10 years?
Oladon has joined #commonlisp
<_death>
loke: I don't know about 10 years.. but there was a recent commit saying they need to get it fixed before release
<loke>
_death: Well, last time I was ranting about CLISP being pretty much dead, I was told they just needed to fix one bug before they could release. And that was at least 3 years ago.
* _death
shrugs
<pjb>
loke: :-)
<luis>
Well, I use CLISP 2.49 for a thing or two, and it works for me!
<luis>
2.49 is 10 years old, not 15 btw
<fiddlerwoaroof>
3 years is barely any time here, though
<_death>
luis: it works, but it'd be nice if it had a more up-to-date asdf.. and also if distros would compile it with multithreading support
dsk has quit [Ping timeout: 268 seconds]
mindCrime has joined #commonlisp
<fiddlerwoaroof>
So, aside from Lisp-Critic, are there any "linters" for CL?
<_death>
#commonlisp-critic :)
<phoe>
the SBCL compiler :D
v88m has quit [Remote host closed the connection]
<aeth>
I think normally people just compile under SBCL + CCL. SBCL will catch more than the others. CCL will catch a few things SBCL does not because CCL has a different interpretation of the standard in a few places, in particular, when DEFCONSTANT is evaluated.
<aeth>
(In practice, that just means DEFCONSTANTs used at certain times, like inside of DEFMACROs iirc, need to be wrapped in EVAL-WHEN to work in CCL)
<jmercouris>
Exactly what aeth said
phadthai has joined #commonlisp
<jmercouris>
We compile on CCL and SBCL, any code with compiler warnings results in a failure in our CI
<luis>
jmercouris: after decades using ACL, our code compiles with a /lot/ of warnings on SBCL
<luis>
tens of thousands
<_death>
how many of these are not notes/style-warnings?
<fe[nl]ix>
luis: is Siscog finally moving to SBCL in production ?
domovod has quit [Quit: WeeChat 3.1]
waleee has quit [Ping timeout: 268 seconds]
waleee has joined #commonlisp
yitzi has quit [Quit: Leaving]
<fiddlerwoaroof>
linting isn't just about non-conforming code, usually
<fiddlerwoaroof>
The idea would be to call out things like bad indentation before it gets pasted here for people to decipher
<fiddlerwoaroof>
And to automate the sorts of rules of thumb you find in LUV
<fiddlerwoaroof>
(e.g. using a default NIL value as a boolean)
<fiddlerwoaroof>
It's about reducing the burden of implementing a style-guide, roughly
<phoe>
I don't think there exists one
<phoe>
maybe scymtym and beach have something in their minds based on eclector
<Shinmera>
In other news, sabra has been working on an absolute monster of an overview of testing frameworks in Lisp. It's over 200 pages when printed, which is crazy. I've had the privilege of reading a draft, and it's good and comprehensive.
<Shinmera>
Can't wait for it to be public!
<phoe>
:O
<phoe>
let me be the first to ask the obvious question
<Shinmera>
I'm quite happy that in the end he recommends parachute! :)
yitzi has joined #commonlisp
mindCrime has quit [Ping timeout: 265 seconds]
<Xach>
it is amazing
<Xach>
(the document - i have not yet tried parachute but I will)
<Shinmera>
yeah, when he first contacted me about it I didn't expect anything on this scale.
<phoe>
it is somewhat incomplete
<phoe>
cl:assert is not on the list
pjb has quit [Read error: Connection reset by peer]
<_death>
it also misses a recent, interesting library by mega called journal
<phoe>
oh I see there are shots fired at the cookbook
* phoe
makes an issue
<cage>
awesome article!
<cage>
i can find some useful suggestions to improve a test framework :)
Bike has joined #commonlisp
<phoe>
oh goodness, protest is mentioned in there
<phoe>
now that's *thorough*
pjb has joined #commonlisp
ad-absurdum has joined #commonlisp
ad_absurdum has quit [Ping timeout: 272 seconds]
<jackdaniel>
nice post
Josh_2 has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
srhm has joined #commonlisp
tyson2 has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
mindCrime has joined #commonlisp
slant has quit [Ping timeout: 264 seconds]
<luis>
makes me want to write a new test suite!
<luis>
test framework, I mean
<jcowan>
There is always that itch, when you see a list of similar things and their advantags and disadvantages, to write a new one that is Practically Perfect in Every Way.
<phoe>
xkcd standards
<jcowan>
In my case I am writing a Scheme string library, because none of the existing five libraries can garner enough votes to make it into R7RS-large.
<pjb>
Sounds like a good reason :-)
<jcowan>
It may indeed make things worse, but I do control (short of an override by the members) which libs go on the ballot.
<didi>
So I guess I should drop FiveAM in favor of parachute.
<luis>
didi: which parachute feature are you missing from fiveam?
<didi>
luis: Eer, none. I don't know parachute. I was referring to the article linked above. I'm a very casual user of FiveAM.
<didi>
Tho FiveAM could use a little more documentation if you ask me.
slyrus2 has quit [Quit: Leaving]
v88m has joined #commonlisp
shka has quit [Ping timeout: 264 seconds]
yitzi has quit [Quit: Leaving]
nature has joined #commonlisp
sjl has joined #commonlisp
<scymtym>
i think the fiveam entry in table 8 is not completely correct. the variable FIVEAM:*RUN-TEST-WHEN-DEFINED* controls whether, well, tests are immediately run when defined
pve has quit [Quit: leaving]
yitzi has joined #commonlisp
<scymtym>
table 12 says "Every assert" for fiveam, but (let ((fiveam:*test-dribble* (make-broadcast-stream))) (fiveam:run! …)) runs without output so it should probably say "optional"
mindCrime has quit [Ping timeout: 264 seconds]
<scymtym>
the fiveam example contains (test t1-fail :documenation [sic] "describe t1-fail" …). i'm pretty sure it should be (test t1-fail "describe t1-fail" …) instead. this also explains why the following listing contains "T1-FAIL in S0 []:" instead of "T1-FAIL in S0 [describe t1-fail]:"
ircseeker has joined #commonlisp
ircseeker has quit [Excess Flood]
yitzi has quit [Quit: Leaving]
akoana has joined #commonlisp
prite has quit [Ping timeout: 244 seconds]
nature has quit [Quit: Lost terminal]
<Shinmera>
scymtym: I'm sure he'd appreciate a mail about it! :) sabra.crolleton@gmail.com
<scymtym>
Shinmera: composing, thanks
<Shinmera>
scymtym: By the way, I don't suppose you've handed the latest version of Kandria to your kid? I'd be interested in hearing what they think about it, now that there's actual content
ad-absurdum has quit [Quit: Leaving]
mindCrime has joined #commonlisp
Nilby has quit [Ping timeout: 244 seconds]
hubvu has joined #commonlisp
casual_friday has quit [Remote host closed the connection]
casual_friday has joined #commonlisp
<aeth>
why don't we have an irc.lisp.org
<White_Flame>
it sounds like running an IRC server is almost as burdensome as running an email server, in terms of spam/security/etc
IUSR has quit [Ping timeout: 252 seconds]
iisi has quit [Ping timeout: 244 seconds]
jmercouris has quit [Ping timeout: 264 seconds]
iisi has joined #commonlisp
jmercouris has joined #commonlisp
IUSR has joined #commonlisp
random-nick has quit [Ping timeout: 264 seconds]
<_death>
it could redirect to libera.. and when libera gets purchased by a second prince, the link can be updated
<White_Flame>
ah, just via DNS, sure. I think gnu does that
akoana has quit [Quit: leaving]
blihp26 has joined #commonlisp
<blihp26>
Anyone know how to create a window with a transparent background in cl-cffi-gtk?