judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
urek has quit [Ping timeout: 272 seconds]
abel-abe_ has joined #lisp
abel-abel has quit [Ping timeout: 256 seconds]
judson_ has joined #lisp
krid has quit [Quit: ERC (IRC client for Emacs 27.1)]
krid has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
EvW has quit [Ping timeout: 244 seconds]
shifty has joined #lisp
abel-abe_ has quit []
surabax has quit [Quit: Leaving]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rumbler31 has quit [Read error: Connection reset by peer]
hendursaga has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
hendursaga has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
thmprover has joined #lisp
PuercoPop has joined #lisp
<thmprover>
Random question: is there any strong consensus about package-name and directory structure? E.g., in Clojure, each namespace has its name be the file name, and subdirectory as prefix to namespace...does Common Lisp informally do likewise? Or is it all pushed in one giant package?
<no-defun-allowed>
It highly depends.
<no-defun-allowed>
But the alternative, from experience, is "giant files".
mbomba has joined #lisp
v0|d has quit [Remote host closed the connection]
v0|d has joined #lisp
<no-defun-allowed>
In my implementation of Netfarm, there are 30 files, each about 50-70 LOC, in one package. There are about 80 exported symbols from memory.
<PuercoPop>
thmprover: There is no strong consensus, but most people use one package per project. There is a one package per file style supported by ASDF and some people do you prefer it. That style is the most similar to the one you'll find in Clojure.
<no-defun-allowed>
Another interesting example is a CLIM implementation; there are many files with (in-package :clim-internals), but they export symbols in some other packages (CLIM, CLIM-EXTENSIONS, etc). And my networking code and Petalisp have several modules, each with a package.
<thmprover>
I've just been sweeping my quasi-CAS into a ./math/ subdirectory of my project, it *feels* natural to include ".math." as part of the package name, but that's a Clojure habit I've acquired
<PuercoPop>
thmprover: You do you boo!
<no-defun-allowed>
The Java teacher at this university told us that you name the files the same name as the classes so that you can always find the implementation of a class without using a search tool. Now, without using a search tool, how do I find the method toUpperCase in java/lang/String.java?
<no-defun-allowed>
But do whatever suits you and your design, really.
igemnace has joined #lisp
<thmprover>
One more question: what conventions are there for docstrings? I infer from the few examples given that UPPERCASE is used for function parameters, and when referring to other functions in my own codebase I defined I should wrap the `function-name' in quotes (like thus).
adam4567 has joined #lisp
<no-defun-allowed>
I've always written parameters and function names upcased, or as normal if some noun matches the name of a parameter, eg (defun not-actually-subseq (sequence start end) "Return the contents of a sequence from the start to end positions" ...)
mbomba has quit [Quit: WeeChat 3.0]
nkatte has quit [Ping timeout: 264 seconds]
loke has joined #lisp
rumbler31 has quit [Remote host closed the connection]
mparlaktuna has quit [Quit: Leaving]
rumbler31 has joined #lisp
wxie has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
zcheng3 has quit [Ping timeout: 265 seconds]
rumbler31 has joined #lisp
wxie has quit [Remote host closed the connection]
wxie has joined #lisp
pankajsg has joined #lisp
rumbler31 has quit [Remote host closed the connection]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
nkatte has joined #lisp
tempest_nox has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
nkatte has quit [Ping timeout: 272 seconds]
nkatte has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
verdammelt has joined #lisp
aartaka has joined #lisp
Alfr has joined #lisp
_jrjsmrtn has joined #lisp
Alfr_ has quit [Ping timeout: 240 seconds]
__jrjsmrtn__ has quit [Ping timeout: 264 seconds]
skapate has joined #lisp
<beach>
Good morning everyone!
oni-on-ion has joined #lisp
skapata has quit [Ping timeout: 272 seconds]
saganman has joined #lisp
verdammelt has left #lisp ["ERC (IRC client for Emacs 27.1)"]
judson_ has joined #lisp
<beach>
thmprover: I find it best to have one directory, one package, and one ASDF system definition per *module*. Such a module can have several source files with one and the same initial IN-PACKAGE form.
<beach>
This way, another module can "use" another module by adding its system name to the list of dependencies in its own ASDF system definition.
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
<beach>
I have yet to see any advantages of a package per file. Every time it is brought up, I learn about contortions that are needed in order to avoid a single huge file for the module or a proliferation of packages that have no semantic meaning.
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<oni-on-ion>
back in the day afaiu, more code was per .lisp file
<thmprover>
beach: that is a sound and reasonable design decision. The problem I have is the modules are all really tightly coupled together.
<beach>
Then they aren't "modules".
<beach>
By definition a "module" has a very small interface to the outside world compared to its implementation.
judson_ has quit [Ping timeout: 272 seconds]
<beach>
Ousterhout (I think it was him) calls them "deep" modules. He uses the image of a rectangle with constant area representing the code size, and the top edge representing the interface.
<beach>
So you want your rectangle to be deep and narrow.
<thmprover>
Yeah, the program is a quasi-CAS with applications to physics (analytical mechanics and field theory), which makes it hard to separate out the code into modules. Ironically, it's for the same reason people called this stuff "beautiful" for a couple centuries...
<thmprover>
I'm sure it's going to be clearer as I continue plugging along, because right now my goals are fuzzy ("do science"). Later, after I have more infrastructure set up, it will become clearer (e.g., "handle celestial mechanics") and, hopefully, even clearer as I progress.
<beach>
How is your system different from Maxima?
<oni-on-ion>
i like this metaphor imagery
<beach>
thmprover: Or is it just that you want to implement this stuff in order to learn?
<beach>
oni-on-ion: Yes, not bad at all.
<thmprover>
beach: isn't Maxima exclusively a CAS? I was hoping to write some GOFAI to do science, in the sense of answering questions and solving problems (not doing any labwork, though).
<oni-on-ion>
lisp+repl is a good platform for having a scratch file, like a pottery floor. then seperate/order stuff out as things solidify
<beach>
thmprover: I am not a domain expert so you may very well be right.
<no-defun-allowed>
You can write list processing and structure processing programs in Maxima, but the evaluation model is a bit wonky.
cantstanya has quit [Ping timeout: 240 seconds]
<thmprover>
I'll look at Maxima as a library, but the main goal is to have a Lispy Leibniz AI do science. Gordon Novak has a simple Lisp program that's a proof-of-concept of simple problems (you can try it online https://www.cs.utexas.edu/users/novak/cgi/physdemod.cgi).
nkatte has quit [Ping timeout: 272 seconds]
<thmprover>
Egads, it's late, time for bed. Good night, all!
thmprover has quit [Quit: ...and miles to go before I sleep.]
nkatte has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
nkatte has quit [Ping timeout: 272 seconds]
nkatte has joined #lisp
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
Alfr has quit [Remote host closed the connection]
nkatte has quit [Read error: Connection reset by peer]
nkatte has joined #lisp
Alfr has joined #lisp
wxie has joined #lisp
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
vzcx has joined #lisp
nkatte has quit [Quit: Quit]
nkatte has joined #lisp
nkatte has quit [Client Quit]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
vzcx has quit [Ping timeout: 260 seconds]
aaaaaa has quit [Quit: leaving]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
krid has quit [Ping timeout: 240 seconds]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
notzmv` has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
notzmv has quit [Ping timeout: 240 seconds]
jdz has quit [Remote host closed the connection]
narimiran has joined #lisp
gutter has quit [Quit: Bye...]
Misha_B has left #lisp ["ERC (IRC client for Emacs 26.3)"]
<oni-on-ion>
how come defvar cannot provide both functionality of itself, as well as defparameter ?
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
<beach>
Because the two have contradictory behavior?
<beach>
You would need a keyword parameter then, like :SET-IF-BOUND.
Cymew has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<oni-on-ion>
ahh; i would have figured that defparam with no second arg could act as defvar
* oni-on-ion
naive
orivej has joined #lisp
kir0ul_ has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
pankajsg has quit [Ping timeout: 265 seconds]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
pankajsg has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<loke[m]>
phoe: Beach suggested a talk about maxima/climaxima. Would that be of interest?
Oladon has quit [Quit: Leaving.]
beach has quit [Remote host closed the connection]
imode has quit [Ping timeout: 256 seconds]
torbo has quit [Remote host closed the connection]
beach has joined #lisp
imode has joined #lisp
<beach>
I am trying to figure out under which circumstances DEFMETHOD calls ENSURE-GENERIC-FUNCTION, and which what arguments.
<beach>
DEFMETHOD can't blindly call ENSURE-GENERIC-FUNCTION because it would need to supply some :LAMBDA-LIST keyword argument, and if it just supplies its own (with specializers and default arguments removed) then the generic function will be reinitialized without any reason.
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
imode is now known as ava
ava is now known as imode
retropikzel has quit [Quit: retropikzel]
<beach>
As long as the lambda lists are congruent, DEFMETHOD should at least avoid passing a different lambda list to ENSURE-GENERIC-FUNCTION.
andreyorst` has joined #lisp
retropikzel has joined #lisp
<beach>
But should DEFMETHOD also check the METHOD-CLASS?
<beach>
I guess DEFMETHOD can just call ENSURE-GENERIC-FUNCTION and rely on it to either reinitialize or signal an error.
Stanley00 has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<beach>
I think I need to re-read the MOP section about initialization of generic-function metaobjects.
skapate has quit [Remote host closed the connection]
andreyorst_ has joined #lisp
<beach>
Nothing special there. Let me check ADD-METHOD.
<beach>
Nothing special there either.
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
<beach>
Does that mean that it's OK for a generic function to have methods of different classes?
<beach>
If so, DEFMETHOD should not pass the :METHOD-CLASS keyword argument to ENSURE-GENERIC-FUNCTION either.
<no-defun-allowed>
Does the MOP require accessor methods to be of a different class?
<beach>
I don't think so.
<beach>
But the typically are.
<beach>
I mean, nothing prevents you from doing (defmethod thing ((x some-class)) (slot-value x '%thing))
Blukunfando has joined #lisp
andreyorst_ has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
standard-accessor-method?
<beach>
Yes, standard-reader-method and standard-writer-method are the ones used by the :READER/:WRITER/:ACCESSOR slot options.
<beach>
... typically.
<no-defun-allowed>
Yeah, but accessor methods have the slot definition accessible with accessor-method-slot-definition.
<beach>
Correct.
<beach>
That fact means that we can optimize the slot access.
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<beach>
Instead of going through SLOT-VALUE it is often possible to do STANDARD-INSTANCE-ACCESS instead.
<no-defun-allowed>
So (defgeneric foo (object)) (defmethod foo ((object number)) object) (defclass bar () ((baz :reader foo))) would create a generic function FOO with one STANDARD-METHOD and one STANDARD-READER-METHOD.
<beach>
Sounds right.
<no-defun-allowed>
So that generic function would require having methods of different classes.
<beach>
True, but STANDARD-READER-METHOD is a subclass of STANDARD-METHOD.
<no-defun-allowed>
Indeed.
<beach>
I guess I wasn't clear about that. I meant if you evaluate a DEFMETHOD with a class that is not a subclass of the METHOD-CLASS of the generic function in question.
<no-defun-allowed>
I see what you mean now.
<beach>
I think that is acceptable, actually.
Blukunfando has quit [Excess Flood]
<beach>
I think the METHOD-CLASS just provides the default when no explicit method class is indicated to DEFMETHOD.
<no-defun-allowed>
That makes sense to me.
<beach>
And, if so, the :METHOD-CLASS keyword argument should not be passed from DEFMETHOD to ENSURE-GENERIC-FUNCTION when the generic function already exists.
<phoe>
loke[m]: very yes
Blukunfando has joined #lisp
<beach>
Hmm, wait! So maybe DEFMETHOD should not call ENSURE-GENERIC-FUNCTION at all if the generic function already exists.
<beach>
That makes a lot of sense actually.
<beach>
It should just check that the lambda lists are congruent.
<beach>
I am saying that, because there is no information in the DEFMETHOD form that would justify a reinitialization of the generic function.
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
pankajsg has quit [Quit: Konversation terminated!]
pankajsg has joined #lisp
shka_ has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<beach>
no-defun-allowed: Thanks for talking this over with me.
<no-defun-allowed>
Sure.
<beach>
Does my conclusion make sense?
<no-defun-allowed>
Yes, I think so.
Blukunfando has quit [Remote host closed the connection]
urek has joined #lisp
<beach>
Great! I'll go with that and see what happens.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
wxie has quit [Remote host closed the connection]
jdz has joined #lisp
andreyorst has quit [Quit: WeeChat 3.0]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
andreyorst has joined #lisp
gproto23 has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
aartaka_d has joined #lisp
hiroaki has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 272 seconds]
aartaka has quit [Ping timeout: 260 seconds]
jprajzne1 has joined #lisp
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
aorst has joined #lisp
pve has joined #lisp
andreyorst has quit [Read error: No route to host]
andreyorst has joined #lisp
scymtym has joined #lisp
liberliver has joined #lisp
aorst has quit [Ping timeout: 260 seconds]
benjamin-l has quit [Ping timeout: 264 seconds]
amb007 has quit [Read error: Connection reset by peer]
retropikzel has quit [Quit: retropikzel]
amb007 has joined #lisp
retropikzel has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
frodef has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
random-nick has joined #lisp
galex-713 has joined #lisp
hendursa1 has joined #lisp
gigetoo has quit [Read error: Connection reset by peer]
lotuseater has quit [Remote host closed the connection]
gigetoo has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
toorevitimirp has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
kaftejiman has quit [Remote host closed the connection]
amb007 has joined #lisp
adam4567 has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
urek has quit [Ping timeout: 272 seconds]
amb007 has joined #lisp
dreamcompiler has quit [Read error: No route to host]
dreamcompiler has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
enrio has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
retropikzel has quit [Quit: retropikzel]
amb007 has quit [Read error: Connection reset by peer]
<pve>
Hi! So reading the logs I learn about "standard-instance-access". I should probably prefer that over slot-value in my accessor functions. I can't seem to find a function in the MOP that lets me look up a slot-definition by name. Do I need to go through "class-slots" to find it?
amb007 has joined #lisp
<pve>
(the goal is to get the slot-definition-location)
<phoe>
pve: there is a GF named slot-definition-location
<phoe>
you need to feed it the effective slot definition object
<pve>
phoe: Yes, I know. I was asking if I can look up the definition by name.
<pve>
or if I need to "find" it from the list returned by "class-slots".
<phoe>
likely, yes, you need to find it
<phoe>
class-slots returns a list of ESDs
<pve>
Alright, that's fine.
<pve>
thanks
<beach>
pve: phoe is right (of course). But you need to respect the conditions associated with STANDARD-INSTANCE-ACCESS.
<pve>
beach: Yes, I was wondering about that.
<beach>
pve: In particular, a slot with a certain name can have different locations in instances of different classes.
adlai has joined #lisp
<pve>
I would have to look up the location for every accessor separately.
<pve>
for each class
<beach>
Well, typically that is handled in COMPUTE-EFFECTIVE-METHOD or thereabouts.
shifty has quit [Ping timeout: 240 seconds]
<beach>
Once the class effective slots are known, the location of each one is also known.
<pve>
beach: Ok, and if the class is redefined, the old locations are no longer necessarily valid?
<phoe>
yes
<beach>
Correct.
<pve>
great
<beach>
So, for example, in SICL, the call history of a generic function will have an entry for each combination of exact argument classes, and the locations are unique for such an entry.
<beach>
But then, if a class is redefined, entries that depend on that class are removed.
<phoe>
if redefining a class munges the slots in any way, then the instance is obsolete and should not be accessed via s-i-a
<phoe>
redefining a class in a way that doesn't change its slots in any way is fine.
<phoe>
so e.g. changing the documentation string in (:documentation "...")
<phoe>
or, AFAIK, adding/removing accessors from individual slot definitions.
karlosz has quit [Ping timeout: 256 seconds]
<pve>
can an obsolete instance be made up-to-date by reinitializing it?
<phoe>
"During updating, the generic function update-instance-for-redefined-class will be invoked."
<beach>
In fact, passing an obsolete instance to any generic function should trigger the update.
<pve>
oh, so I'm really looking UPDATE-INSTANCE-FOR-REDEFINED-CLASS?
<pve>
looking for
<phoe>
yes, but is there a facility in CL that explicitly updates an instance?
<phoe>
u-i-f-r-c is not supposed to be directly called by programmers
<phoe>
well then, what is?
<beach>
Yes, but it should be handled automatically, unless you are creating your own Common Lisp implementation of course.
<phoe>
beach: he kinda is
<beach>
Ah.
<phoe>
he's working on a Smalltalk implementation in CL, which is similar enough
<beach>
Oh, now I remember.
<scymtym>
phoe: MAKE-INSTANCES-OBSOLETE
<pve>
hmm I need to think about this.. at this point the accessors are using slot-value, and it works fine. But using standard-instance-access would be nice too.
<phoe>
scymtym: no no, this makes an instance obsolete
<phoe>
what makes an obsolete instance non-obsolete?
<scymtym>
phoe: oh, i see. didn't read carefully enough
urek has joined #lisp
andreyorst has quit [Quit: WeeChat 3.0]
<pve>
phoe: you make it sound so serious, my implementation is anything but :)
<adlai>
it does not trigger updating, either.
<adlai>
only marks obsoletion.
gproto23 has quit [Ping timeout: 260 seconds]
<phoe>
pve: it's the most advanced Smalltalk-in-CL implementation that I'm aware of!
<pve>
hehe
treflip has joined #lisp
perrier-jouet has quit [Quit: WeeChat 2.9]
stoneglass has joined #lisp
enrio has quit [Remote host closed the connection]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
vegansbane has joined #lisp
saganman has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
urek has joined #lisp
amplituhedron has joined #lisp
kaftejiman has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
hhdave has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
pankajsg has quit [Ping timeout: 256 seconds]
cosimone has joined #lisp
surabax has joined #lisp
Stanley00 has quit [Remote host closed the connection]
Stanley00 has joined #lisp
<gendl>
mfiano: so you didn't use checkout.js in your stripe api, correct?
<gendl>
you were always using the full-blown api where you do the whole UI by yourself and call the stripe api explicitly
<jmercouris>
let's say I have the following (list 0 1 1 1 2 2 3) and I want to return a list with all of the matching elements like this (list (list 0) (list 1 1 1) (list 2 2) (list 3))
<jmercouris>
what is a good way to do this?
<jmercouris>
so far I thought of keeping a "counter" and incrementing all matches
<jmercouris>
but that is a rather inefficient way, as I will have to traverse the list multiple times
<jmercouris>
my idea was: find all 0, find all 1, find all 2, etc...
<adlai>
is it guaranteed unsigned-byte monotonic?
<jmercouris>
there is no guarantee
<jmercouris>
only that I want to group matching elements by some predicate
<adlai>
ah, that is the exact problem that failed me a "job interview" around age sixteen.
<jmercouris>
the predicate being #'eql i nthis case
* adlai
began thinking about a general case instead of "just use a matrix, bro"
<flip214>
jmercouris: how about counting equal elements, eg. into a hash-table?
<flip214>
a list of identical things is possible as good as the thing and the count
<jmercouris>
flip214: perfect!
<jmercouris>
yes, I've even done that exact same thing elsewhere in the codebase!
<jmercouris>
I had forgotten about it, thank you
<flip214>
you're welcome
<adlai>
for bonus points, destructively reuse the conses of the original list, and dynamic-extent the hashtable :)
<jmercouris>
this is not an interview question, but anyways :-D
<phoe>
(let ((result (make-hash-table))) (loop for x in (list 0 1 2 3 4 4 4 5) do (push x (gethash x result '()))) (alexandria:hash-table-values result))
<phoe>
it gives you a hashtable where seq elements are keys and their counts are values
liberliver has quit [Ping timeout: 240 seconds]
<jmercouris>
that won't work for me
<jmercouris>
I'm afraid
<jmercouris>
I am posting a really simplified version of my problem here
<phoe>
yes, I assume that your values are more complex
<phoe>
in this case the push solution will work the best
<jmercouris>
indeed, thanks phoe
<phoe>
<3
<adlai>
if there is no guarantee that the test predicate is #'eql, then you can't use a histogram function
* adlai
interprets jmercouris's original example as including the #'eq elements from the original list
<jmercouris>
it does actually include the elements from the original list, yes
Bike has joined #lisp
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
ldb has joined #lisp
liberliver has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
leo_song_ has quit [Ping timeout: 256 seconds]
kir0ul_ has joined #lisp
stoneglass has quit [Quit: stoneglass]
hendursa1 has quit [Ping timeout: 240 seconds]
hendursa1 has joined #lisp
<Josh_2>
afternoon
<phoe>
heyyyy
lotuseater has joined #lisp
gko_ has joined #lisp
liberliver has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
liberliver has joined #lisp
KREYREEN has quit [Remote host closed the connection]
pankajsg has joined #lisp
KREYREEN has joined #lisp
ldb has quit [Remote host closed the connection]
orivej has joined #lisp
rumbler31 has joined #lisp
cosimone has joined #lisp
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
pfdietz has joined #lisp
akrl has quit [Read error: Connection reset by peer]
hendursa1 has quit [Quit: hendursa1]
akrl has joined #lisp
hendursaga has joined #lisp
galex-713 has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
saganman has quit [Read error: Connection reset by peer]
abel-abel has joined #lisp
narimiran has joined #lisp
kaftejiman_ has joined #lisp
gproto023 has joined #lisp
gproto023 has quit [Client Quit]
gproto23 has quit [Ping timeout: 240 seconds]
kaftejiman has quit [Ping timeout: 256 seconds]
Fare has quit [Ping timeout: 264 seconds]
gko_ has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
CrazyEdd has quit [Ping timeout: 246 seconds]
wsinatra has joined #lisp
enrio has quit [Remote host closed the connection]
enrio has joined #lisp
Fare has joined #lisp
enrio has quit [Remote host closed the connection]
enrio has joined #lisp
jprajzne1 has quit [Quit: Leaving.]
scymtym has quit [Ping timeout: 240 seconds]
abel-abel has quit [Read error: Connection timed out]
vaporatorius has joined #lisp
abel-abel has joined #lisp
<phoe>
OK, the wasm talk is bound to happen in like 98 minutes from now
<beach>
By webcam?
<phoe>
by webcam + slides
<beach>
And is it public?
urek has quit [Ping timeout: 272 seconds]
hhdave has joined #lisp
<Gnuxie[m]>
Wait, you're actually talking to them about control flow?
<phoe>
I have no idea; the link to the zoom meeting is there on the website
vaporatorius__ has quit [Ping timeout: 240 seconds]
<phoe>
Gnuxie[m]: yes, blame ioa for that
<beach>
phoe: Good luck!
<Gnuxie[m]>
Epic
<aeth>
phoe: how does it feel to be the public face of Common Lisp?
<Gnuxie[m]>
Lol
<phoe>
aeth: on one hand I hope that my work is useful
<pfdietz>
Where is this talk?
<minion>
pfdietz, memo from phoe: I have some people who are interested in your work on random-testing the SBCL compiler and the techniques you used and the effects that it had and the bugs that it uncovered; is there any published code/research that I should link them to?
<minion>
pfdietz, memo from phoe: also, if you ever have the time to prepare and speak about it, I would love to listen to this on an Online Lisp Meeting someday (and so would these people).
<aeth>
heh, maybe I should've asked that after the talk so you didn't get too nervous
<phoe>
on the other I am absolutely fidgetful inside
<pfdietz>
phoe: the only published work is the ansi-tests paper back at ILC 2005
<phoe>
aeth: yes, and it's marvelous because of that
<phoe>
travv0: I explicitly do not say that other people should join; I'm just pointing out that the meeting link is public, which might or might not be intentional - likely the latter
<travv0>
well good luck with the talk
<phoe>
thanks
bitmapper has quit [Quit: Connection closed for inactivity]
urek__ has joined #lisp
vaporatorius__ has joined #lisp
<aeth>
Hmmm... I wonder if I should try to programmatically convert the ANSI Common Lisp test files to test Airship Scheme CL compatibility. In theory, the semantics should be preserved where they make sense, even though in practice, many things (e.g. the macros like LOOP) would require reimplementations...
<aeth>
The only hard parts would be things that take advantage of the lisp-2 nature of CL while naming variables...
urek has quit [Ping timeout: 272 seconds]
vaporatorius has quit [Ping timeout: 260 seconds]
bitmapper has joined #lisp
<pfdietz>
ansi-tests is really a combination of two things that should be separated: the tests traceable to specific parts of the spec, and the random testing infrastructure (which itself is composed of several different approaches.)
<aeth>
Hmmm... I actually wonder if the easiest way to use ansi-tests might be to make the meme a reality and implement CL in Scheme in CL...
skapata has joined #lisp
<pfdietz>
The random tests come in three main flavors: generation of random integer-value forms to test the compiler, "random type prop" types that try to test type inference on small functions, and a mutational testing scheme that stitches together fragments of lisp code from public lisp projects to try to get the SBCL compiler to throw errors (this last
<pfdietz>
part is really only useful on SBCL.)
ebrasca has joined #lisp
<phoe>
aeth: is the inverse of Airship Scheme is going to be Ground Vehicle Common Lisp?
<pfdietz>
Err, "random type prop" *tests*
<phoe>
s/is//
<aeth>
phoe: no, the inverse would be some form of submarine.
kaftejiman__ has joined #lisp
<aeth>
The point of implementing CL in Scheme in CL, of course, would be to (1) ensure that the semantics of the functions are preserved and (2) ensure that the reimplemented macros (at the very least, the iteration ones) are semantically identical.
<aeth>
It would otherwise just lose performance and from the outside look just like a meme.
kaftejiman_ has quit [Ping timeout: 240 seconds]
<phoe>
and so you can run CL applications on Scheme and therefore verify the intermediate Scheme layer
<aeth>
jcowan: Airship Scheme? It passes the first test, i.e. it reads the test file. This was fairly non-trivial.
<aeth>
Slower than expected, but I wanted to do it a little piece at a time.
<pfdietz>
I'm afraid I got a bit snippy on r/scheme when someone complained about all the funcalls in Common Lisp. If you look at quicklisp, about 0.4% of lines have a funcall on them. Granted, Scheme-style Common Lisp would have more.
urek__ has quit [Ping timeout: 272 seconds]
<aeth>
I probably could've worked through the reader in a few days if I was willing to sacrifice quality.
urek has joined #lisp
<aeth>
pfdietz: I saw that and nobody got that right... You don't use funcalls for FP, you use it for higher-order-functions, which are just a subset of FP. And CLers use a lot of higher-order-functions, but usually ones that are preexisting, like map/mapcar.
<aeth>
jcowan: If I added semantics to define, I could probably get some minimal Scheme-like going already.
<flip214>
phoe: this presentation is great! a bit too many repeated pages, and still okay
<phoe>
flip214: you mean the slides I linked in the PR?
<aeth>
jcowan: As it stands, I can do this and it will read because I'm only missing #1= and #1# labels (like in the /topic here) in the reader: (with-open-file (s #P"~/git/other/no-backup/chibi-scheme/tests/r7rs-tests.scm") (scheme-read s))
yottabyte has joined #lisp
<aeth>
(That test file has them, but only in literal strings)
<phoe>
I flip* through these slides real quick to animate their contents; 240 slides took me like 50 minutes to go through on the last Online Lisp Meeting
<phoe>
or maybe the last OLM was scavenged from those slides?... I don't know anymore
<flip214>
phoe: please like the video
<flip214>
*link
<Josh_2>
Did you swap any thinks for thonks?
<phoe>
flip214: from the wasm meeting? there won't be one, it will not be recorded
<phoe>
Josh_2: no
<Josh_2>
ah shame
pankajsg has quit [Ping timeout: 240 seconds]
<flip214>
I haven't watched a single minute from ELS 2020 yet, but hope persists
<phoe>
flip214: it's worth it! some of these talks were simply amazing
hnOsmium0001 has joined #lisp
<flip214>
phoe: I can guess from the years before...
<phoe>
I remember heisig's greenscreen as the greatest non-strictly-technical thing of ELS 2020
<flip214>
but unless time is really reserved by booking a hotel, it's hard to find it again later on
<phoe>
yes
<flip214>
perhaps 2022 there'll be a real ELS again... I could try to get there 3 days early and watch 2020 and 2021 ;/
<phoe>
that's a Lisp marathon in the making :O
Steeve has joined #lisp
<pfdietz>
I am sad that COVID-19 kept me from physically attending ELS this year.
andreyorst` has quit [Quit: andreyorst`]
<phoe>
pfdietz: we all are
<phoe>
we got a virtual ELS this year though
<edgar-rft>
have you tried to attend chemically?
<phoe>
and the form which ELS took this year gave me an idea for Online Lisp Meetings, so not all related to this year's covid situation is sad
<aeth>
I guess ELS 2021 is either going to be online again or is going to be delayed until the fall. Do we know which one?
<phoe>
aeth: just mailed Didier about it.
<aeth>
It's possible that they're going to wait until closer to the event to decide whether it's online or not, but realistically speaking, until the vaccines are widespread, restrictions will remain in place, i.e. until some point in the middle of the spring
<ioa>
phoe, the stacks subgroup meeting is only for WebAssembly CG members
<ioa>
Oh I see they put the link on the meeting notes - strange, perhaps it is open after all.
<phoe>
ioa: I know, it's confusing to me!
<phoe>
maybe should be clarified
<beach>
phoe: As I recall, in your OLM talk, you did not emphasize the need for special variables. But I guess the WASM people need to understand that.
<ioa>
beach I agree
<phoe>
beach: I did not emphasize it because dynamic variables can be implemented using unwind-protect
<phoe>
so it's not *strictly* necessary
<beach>
Fair enough.
<phoe>
but yes, one of the final slides that are exclusive for the WASM version of the talk mention dynavar support
<phoe>
s/mention/mentions/
amplituhedron has quit [Ping timeout: 240 seconds]
<ioa>
cool!
Cymew has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
enrio has quit [Remote host closed the connection]
andreyorst has joined #lisp
scymtym has joined #lisp
KREYREEN has quit [Remote host closed the connection]
EvW has joined #lisp
fragamus has joined #lisp
<jcowan>
Is there a program that can validate a fully macroexpanded CL program short of compiling it?
<phoe>
validate, as in?
amplituhedron has joined #lisp
<phoe>
that it will compile without any warnings and/or errors on a given compiler?
<phoe>
that it will return without signaling an error? (that's already halting problem territory)
fragamus has quit [Ping timeout: 240 seconds]
CrazyEdd has joined #lisp
enrio has joined #lisp
andreyorst is now known as andreyorst_
<ioa>
phoe Wasm is typed and it's type validated before it runs
<ioa>
jcowan, wasm doesn't even have non-local returns yet
<beach>
ioa: Still, there are things that can't be tested unless the language is not Turning complete.
<beach>
s/tested/validated/
<jcowan>
That it will compile without any errors on a compiler that accepts all programs (modulo implementaiton limits) that are valid according to the ANS.
<phoe>
I think that the only such validator is a Common Lisp compiler
liberliver has quit [Ping timeout: 264 seconds]
<Bike>
"validity" would probably include type declarations being accurate, right? since the effects are UB otherwise? so you can probably do something something satisfies and make problems
<beach>
I am pretty sure there are cases where it can't be checked statically whether a program is conforming.
<phoe>
macroexpanding everything already requires a code walker
<Bike>
(the nil (final-twin-prime)) or something
<beach>
Stuff like that.
<phoe>
Bike: wait a second, inside (the nil X) the X is guaranteed to... uh... never return?
<Bike>
probably
<Bike>
i don't think there are any common programs to do validation, anyway
<Bike>
there's ACL2 but that's a subset or something
zcheng3 has joined #lisp
<Bike>
phoe: this is useful in that e.g. ERROR can be declared to have a return type of NIL, and from ther ea compiler can derive that (if (integerp x) (1+ x) (error ...)) has type integer, and such things
<phoe>
Bike: yes, I realized that
<phoe>
the functions ERROR and INVOKE-DEBUGGER have return type NIL because of their contracts
CrazyEdd has quit [Remote host closed the connection]
<jcowan>
phoe: Compilers are generally understood to generate code; in addition, they don't necessarily enforce all the rules of the spec. What I want is a linter.
<jcowan>
At least the correctness part of a linter; I don't care about unidiomatic code.
<lotuseater>
Bike: ACL2 is meant to be functional and for this also side-effect-free
<phoe>
jcowan: SBCL's #'CL:COMPILE is the best linter I am aware of
CrazyEdd has joined #lisp
<Bike>
yeah, i don't think we have a linter.
<mseddon>
sbcl does a pretty good job at keeping me honest tbf.
<phoe>
it also happens to be a compiler, but yeah, it is going to tell you if the code it gets doesn't conform
<mseddon>
well yeah. and honestly 'linting' is best served BY a compiler, since it has all the information to hand and has done significant analysis.
<beach>
jcowan: Still, what you describe is not generally possible.
<beach>
jcowan: So you need some approximate model.
<phoe>
OK, time to connect to Zoom; keep your fingers crossed, and please don't connect yourself since it seems that this meeting is *not* public
<beach>
Good luck!
* phoe
bows, disappears
<phoe>
I'll attempt to lure people to heisig's Jitsi instance for some chat afterwards; I'll tell you if that's successful
<Bike>
doing a linter with cleavir tools might be nice.
<beach>
Indeed.
retropikzel has joined #lisp
enrio has quit [Quit: Leaving]
cosimone has quit [Quit: cosimone]
<jcowan>
S.C. Johnson's "Lint: A C program checker" says: "The separation of function between lint and the C compilers has both historical and practical rationale. The compilers turn C programs. into executable files rapidly and. efficiently. This is possible in part because the compilers do not do sophisticated type checking, 'especially between separately compiled programs. Lint takes a more global, leisurely view of the.
<jcowan>
program, looking much more carefully at the compatibilities. "
<jcowan>
arrgh, bad OCR
<beach>
jcowan: I don't think such a separation is justified.
<beach>
Maybe it was at the time.
liberliver has joined #lisp
<jcowan>
Perhaps not any more. If both compilation and linting are fast enough, it may pay to do them both at once.
liberliver has quit [Client Quit]
enrio has joined #lisp
<Bike>
i think a strict lint might do more analysis than a compiler would be willing to, because it's not actually relevant to optimization/whatever
<beach>
Maybe it is justified for languages such as C++ that have to include huge amounts of code in order to compile a single file.
<jcowan>
Bike: Just so
<beach>
I would vote against such a separation. It may very well create a lot of code duplication, resulting in a higher maintenance burden.
<beach>
I know there are people who don't care much about the maintenance aspect, but I do.
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
gabiruh has quit [Ping timeout: 256 seconds]
gabiruh has joined #lisp
<jackdaniel>
I've read an interview (sorry, I don't remember with whom) about code analysis performed by IDE (I think he was working on vscode) and the claim was that to do a good code analysis of C you basically need to compile it (but not necessarily to the executable)
<jackdaniel>
so basically even for C static code analysis (according to that person) is not sufficient to give a good insight
enrio has quit [Quit: Leaving]
dhil has joined #lisp
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<jcowan>
beach: lint(1) included the first pass of the C compiler with a different back end.
<beach>
I suppose that's good.
<beach>
Even so, I think it's a bad idea. Either the programmer runs both the compiler and the linter each time in which case the compilation time will essentially double. Or else, the programmer will waste time tracking down bugs that the linter would have found.
KREYREEN has joined #lisp
benjamin-l has joined #lisp
<beach>
For C, I have seen lots of people who don't even turn on all the warnings at compile time, and thereby wasting lots of time tracking down bugs that the compiler would have warned about.
EvW has quit [Ping timeout: 246 seconds]
<beach>
I think a much better idea would be to do incremental compilation in an IDE so that the programmer gets immediate feedback. And since it is incremental, it would not take a lot of time.
<beach>
Then the incremental compiler could do the work of the linter as well.
<pfdietz>
git pull
<pfdietz>
Arg
<jackdaniel>
I think that making distinction between compilers and linters is quite superficial (because the former may be repurposed as the latter, and the latter has a big overlap with the former); in other words I agree with beach
abel-abel has quit []
<jcowan>
beach: OTOH, since the linter is not perfect, it may catch non-bugs where the programmer does actually know better. This is the difference between Dialyzer-style static type checkers and more usual ones: the former complain only about code that is provably wrong, whereas the latter complain about code that is not provably right.
<beach>
I see.
<beach>
I still remain unconvinced, perhaps as I would be one of the people who would always run both together.
frodef has quit [Read error: No route to host]
<jcowan>
Which is why most lints (including the original lint) have some convention for suppressing lint output of a particular type and/or at a particular point in the program.
<jcowan>
Usually a comment or pragma
<jackdaniel>
(muffle-warnings … ) :)
<beach>
Such annotations could be observed by the compiler as well.
toorevitimirp has quit [Remote host closed the connection]
<beach>
In Common Lisp we already have things like that, yes, muffle-warnings, (declare (ignorable...))
KREYREEN has quit [Remote host closed the connection]
KREYREEN has joined #lisp
EvW has joined #lisp
galex-713 has quit [Ping timeout: 260 seconds]
andreyorst_ has joined #lisp
cosimone has joined #lisp
heisig has quit [Quit: Leaving]
johnjay has quit [Ping timeout: 260 seconds]
frodef has joined #lisp
galex-713 has joined #lisp
jtecca has joined #lisp
luna_is_here_ has quit [Ping timeout: 240 seconds]
luna_is_here has joined #lisp
shifty has joined #lisp
torbo has joined #lisp
<phoe>
okay
<phoe>
seems like it was a good talk
<Josh_2>
Good :)
<phoe>
I barely touched the condition system because there were lots of questions about the control flow and closures, so the basics - but I linked to the OLM recording so things should be good
jeosol has quit [Ping timeout: 245 seconds]
<phoe>
time to unwind
<Josh_2>
as opposed to restarting?
<phoe>
the CHILL restart I've invoked includes unwinding
urek has quit [Ping timeout: 256 seconds]
urek has joined #lisp
urek has quit [Remote host closed the connection]
<ioa>
It was a great talk, thank you phoe!!
urek has joined #lisp
* phoe
bows
* phoe
continues unwinding
<ioa>
:D
jtecca has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
mimischeme has joined #lisp
* ioa
invokes her debugger and will restart work tomorrow :P
saganman has joined #lisp
urek has quit [Ping timeout: 272 seconds]
urek has joined #lisp
housel has quit [Ping timeout: 265 seconds]
notzmv has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
housel has joined #lisp
mint__ has joined #lisp
amplituhedron has quit [Ping timeout: 256 seconds]
kir0ul_ has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 256 seconds]
gareppa has joined #lisp
shifty has joined #lisp
mint__ has quit [Remote host closed the connection]
mint__ has joined #lisp
urek__ has joined #lisp
urek has quit [Ping timeout: 272 seconds]
gareppa has quit [Remote host closed the connection]
urek__ has quit [Ping timeout: 264 seconds]
gproto23 has joined #lisp
urek has joined #lisp
frodef has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Read error: Connection reset by peer]
madage has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
cosimone has quit [Quit: cosimone]
bilegeek has joined #lisp
shifty has quit [Ping timeout: 264 seconds]
madage has joined #lisp
shifty has joined #lisp
andreyorst_ has quit [Remote host closed the connection]
frodef has joined #lisp
rgherdt has joined #lisp
gproto23 has quit [Ping timeout: 256 seconds]
andreyorst has joined #lisp
andreyorst has quit [Remote host closed the connection]
andreyorst has joined #lisp
andreyorst has quit [Remote host closed the connection]
andreyorst has joined #lisp
andreyorst is now known as andreyorst_
karlosz has joined #lisp
<pfdietz>
phoe: to answer your earlier question about the bugs uncovered by the random tester...
<phoe>
pfdietz: yes
<pfdietz>
phoe: the file misc/misc.lsp in ansi-tests contains a bunch of tests that were examples of failures in various lisps. Many have comments indicating which lisp it was.
<phoe>
(and there was also a question if you'd like to talk about it sometime!)
* phoe
opens
<pfdietz>
These were produced either by the random form generator in random/random-int-form.lsp, or by the "rtp" tests in random/random-type-prop-tests-*.lsp
<pfdietz>
Eric Marsden was running the random tester for a while on sbcl; check the sbcl bug tracker. I have since renewed running it, check my entries there as well. Many of the recent entries are from that mutational tester I mentioned earlier.
<pfdietz>
There are (if I recall correctly) 11 bugs in the clisp bug tracker that came from the random tester.
<pfdietz>
The problem there is tracking down just where that bug tracker is. clisp has moved around.
<phoe>
right now it's on gitlab.com; CCL also switched from trac to github.
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
<pfdietz>
I don't think they carried over the old issues.
<phoe>
I don't think so either; CCL for sure did not
KREYREEN has quit [Remote host closed the connection]
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
codus has joined #lisp
KREYREEN has joined #lisp
cosimone has joined #lisp
Kurvivor has joined #lisp
codus has quit [Client Quit]
<Kurvivor>
good evening. Does anyone have expedience with ECL's asdf:make-build extension? More specifically, with building monolithic static libraries
PuercoPop has quit [Remote host closed the connection]
johnjay has joined #lisp
<Josh_2>
How can I get the current working directory?
<phoe>
Josh_2: uiop:getcwd
<Josh_2>
obviously It's that simple
<Josh_2>
I tried all sorts of variants of pwd but not cwd :P
urek has quit [Ping timeout: 272 seconds]
Stanley00 has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
<phoe>
cwd stands for current working directory
<phoe>
and hmmm, pwd stands for print working directory
<phoe>
I can see the confusion
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
Stanley00 has quit [Ping timeout: 240 seconds]
PuercoPop has joined #lisp
andreyorst_ has quit [Ping timeout: 240 seconds]
kiroul has quit [Ping timeout: 265 seconds]
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
ebrasca has quit [Remote host closed the connection]
andreyorst_ has joined #lisp
retropikzel has quit [Quit: retropikzel]
retropikzel has joined #lisp
kiroul has joined #lisp
andreyorst_ has quit [Ping timeout: 272 seconds]
retropikzel has quit [Client Quit]
retropikzel has joined #lisp
<PuercoPop>
pfdietz: Have you given any thought as to how best integrate code coverage information files or ASDF systems? Both sb-cover and cover work at the level of forms, not files afaiu
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
frodef has quit [Ping timeout: 264 seconds]
<pve>
Is there a function for detecting whether a symbol has been declared a global dynamic variable (even if unbound)?
<phoe>
pve: cltl2:variable-information
wsinatra has quit [Quit: WeeChat 3.0]
<pfdietz>
PuercoPop: sb-cover can be enabled globally. (eval '(declaim (optimize sb-cover:store-coverage-data)))
<pve>
phoe: oh cool!
urek has joined #lisp
<pve>
phoe: is cltl2 supported by most implementations?
<phoe>
pve: (ql:quickload :trivial-cltl2)
<pve>
yeah, I just saw that one
<pfdietz>
For cover, you need to be able to fiddle with packages when annotation is turned on. This could be done by using the macroexpand hook to add that to in-package.
<pve>
thanks
<pfdietz>
The problem I have with sb-cover is that is can screw up when the readtable is changed. It needs to somehow record readtable information to properly annotate source files.
<pfdietz>
cover works at the s-expression level, so that's not an issue there (but the coverage reports are harder to read).
cosimone has quit [Remote host closed the connection]
<pfdietz>
cover fails with some macros that have code walkers, particularly iterate. I have a modified version of iterate that works with an enhanced version of cover.
cosimone has joined #lisp
<pfdietz>
sb-cover does work at the level of files, btw.
<PuercoPop>
pfdietz: yeah, but I'm trying to think about how to compute the coverage 'diff' after running a test. afaiu sb-cover stores a coverage bit for each form it compiles, right? But you still have to check the coverage bit for the forms you care about. There is no way to run (test-foo) and then ask for what new 'paths' have been run
<PuercoPop>
pfdietz: it does? I'll have to look at it again then.
<pfdietz>
I mean, it prints out reports on a file-by-file basis.
<pfdietz>
At previous job, we had an extension of cover that did things like allow rollback of coverage information, and also dumping coverage info to a file for combination (to get aggregate coverage from separate tests). But I left that behind for IP reasons.
<pfdietz>
The rollback would be useful for incremental generation of minimized unit tests that increase coverage.
EvW1 has joined #lisp
EvW1 is now known as EvW
EvW has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
cl-arthur has quit [Read error: No route to host]
<PuercoPop>
fwir the report is built by walking the forms in the file and checking the coverage bit for each form.
<PuercoPop>
So for 'rollbacks' or snapshots one would have to do that and store the information in a datastructure, right? But also one would have to know before hand which files to check. I guess one could use ASDF for that
mimischeme has quit [Remote host closed the connection]
aeth has joined #lisp
rumbler31 has quit [Ping timeout: 272 seconds]
Blukunfando has joined #lisp
cl-arthur has joined #lisp
RukiSama__ has quit [Read error: Connection reset by peer]
arbv has joined #lisp
rumbler31 has joined #lisp
nckx is now known as ncksneekx
ncksneekx is now known as nckx
nihil has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
leo_song has joined #lisp
Stanley00 has joined #lisp
<nihil>
Hey all
<Xach>
hello nihil
<nihil>
hi xach
<Xach>
Are you here for some stimulating Common Lisp chat?
<nihil>
isn't this the speech impediment channel?
<nihil>
:) jk ofc I am
<nihil>
though I was thinking of something that's probably not directly relevant to CL but program design in general...
random-nick has quit [Ping timeout: 256 seconds]
Stanley00 has quit [Ping timeout: 260 seconds]
drl has quit [Remote host closed the connection]
Kurvivor has quit [Ping timeout: 260 seconds]
KREYREEEN has joined #lisp
<phoe>
fire away
<phoe>
in the worst case we'll suggest #lispcafe as a less strictly-on-topic channel
<nihil>
(I'm a beginner in general, and I'm making some little project)
<nihil>
I started making my code more and more modular
KREYREEN has quit [Ping timeout: 240 seconds]
<nihil>
creating a superclass when two classes shared a couple slots
<save-lisp-or-die>
ravioli anyone?
<nihil>
^ my thoughts exactly
<phoe>
nihil: OK, this already sounds kinda lispy
<save-lisp-or-die>
what issues are you bumping up against? Or are you just sort of... feeling uncertain?
Steeve has quit [Quit: end]
<nihil>
I guess it's a question of style, whether it makes sense to make a class to save in slot definitions
<nihil>
I did consider a superclass could make for a somewhat general framework
<nihil>
to make all objects inherit from a set of classes in a sort of mix-and-match
<nihil>
but then I also thought "what about elements that won't require a name and a description?"
dhil has quit [Ping timeout: 256 seconds]
<nihil>
and I came full circle making a blank class just to have everything inherit from it
<nihil>
is that stupid?
kaftejiman__ has quit [Remote host closed the connection]
<save-lisp-or-die>
My personal taste is to not give in to the temptation of "factoring out" classes unless that class will actually serve a different role in the running application.
<ane>
uh, if I have a cffi function like this: void foobar(size_t *blah);, which in C I would call like this size_t blah; foobar(&blah); ... how would I do that using cffi? something like (with-foreign-object (blah :uint) (let ((ptr (foreign-alloc :uint))) (setf (mem-aref ptr :uint) blah) (foreign-funcall "foobar" :pointer ptr :void))
<save-lisp-or-die>
But using "mix -ins" for augmenting "main classes" is a useful strategy for some application domains.
<ane>
but I seem to get some unhandled memory exceptions
<save-lisp-or-die>
nihil without seeing your application, its hard to say what you should do. I see your concern. I say go with your gut and come back when things get hairy
<phoe>
nihil: mixin classes are pretty common
<phoe>
but then again, what exactly should your set of superclasses be depends on your application logic
<phoe>
and that's a question of what you want your inheritance graph to look like, how do you want to apply the Liskov substitution principle, and which classes of your graph are meant to be protocol classes (not meant to be instantiated directly).
<save-lisp-or-die>
nihil like. I wrote a (fairly crappy, just-for-friends) matrix bot framework a while back. It used a mixin approach. I made a main client - then each bot had "components" that I could mix in to customize the behavior of the particular bot in question.
<save-lisp-or-die>
I could even install new behaviors in old bots (while they were running) by adding in a new class to the list of superclasses for the bot in question.
<save-lisp-or-die>
so. It can be a good idea, but it can also get icky. Like people are suggesting. It depends on the specifics of your application.
<nihil>
save-lisp-or-die: oh that sounds like what I'm doing
<save-lisp-or-die>
cool beans
<save-lisp-or-die>
well. It worked well for me
<nihil>
phoe: I'd never heard of the Liskov principle
* nihil
looks stuff up
<phoe>
nihil: in other words
<phoe>
if some place in your code accepts something of class X, it should also accept all subclasses of X
<nihil>
ah yes
<Gnuxie[m]>
save-lisp-or-die: matrix bot? Like the matrix i'm stuck in?
<save-lisp-or-die>
that's correct. I didn't use your (very cool) library though.
miasuji has joined #lisp
<Gnuxie[m]>
Oh ok, that's cool, do you have a repo for your library somewhere?
<save-lisp-or-die>
Gnuxie[m] not really intended for human consumption. Just something that a friend and I were using last summer to play around.
notzmv has quit [Read error: No route to host]
notzmv has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
<Gnuxie[m]>
that's ok, I'll take a look in a minute, thanks
aeth_ has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
aeth_ is now known as aeth
cosimone has quit [Quit: cosimone]
hendursaga has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
codewaffle has quit [Remote host closed the connection]
codewaffle has joined #lisp
bjorkintosh has quit [Read error: Connection reset by peer]
bjorkint0sh has joined #lisp
KREYREEEN has quit [Read error: Connection reset by peer]
KREYREEN has joined #lisp
stux|RC-only has quit [Ping timeout: 260 seconds]
stux|RC-only has joined #lisp
<Gnuxie[m]>
save-lisp-or-die: that's quite nice, I have some ideas in the pipeline to make writing this sort of thing easier in the future, I've not really talked about them too much publicly
<Gnuxie[m]>
if you looked at cl-matrix, you'll notice there's a sort of generator, but i was a bit naive and didn't generalize it at the time but I did start fixing that https://gitlab.com/Gnuxie/rest-api-description
<Gnuxie[m]>
some people have wrote generators for swagger apis but the problem with that is that if the thing you're trying to wrap is not expressed in swagger than you're sorta stuck
<Gnuxie[m]>
so i started trying to make a model for it all in CLOS, but it's a bit of a big task tbh, hopefully you'd be able to do things for webservers from this library too