mrcom has quit [Read error: Connection reset by peer]
alemmens has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 260 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
pve has quit [Quit: leaving]
alemmens has joined #commonlisp
rogersm has quit [Read error: Connection reset by peer]
rogersm has joined #commonlisp
random-nick has quit [Ping timeout: 268 seconds]
alemmens has quit [Ping timeout: 260 seconds]
occ has joined #commonlisp
gxt has quit [Ping timeout: 255 seconds]
gxt has joined #commonlisp
VincentVega has quit [Ping timeout: 272 seconds]
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 264 seconds]
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 265 seconds]
occ has quit [Ping timeout: 272 seconds]
waleee has quit [Ping timeout: 264 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
occ has joined #commonlisp
<beach>
atgreen: If you use Eclector to read your code, you can customize the symbol reader function.
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 255 seconds]
VincentVega has joined #commonlisp
VincentVega has left #commonlisp [#commonlisp]
azimut has quit [Ping timeout: 255 seconds]
occ has quit [Ping timeout: 272 seconds]
contrapunctus has joined #commonlisp
gxt has quit [Ping timeout: 255 seconds]
occ has joined #commonlisp
gxt has joined #commonlisp
alemmens has joined #commonlisp
sloanr has joined #commonlisp
sloanr` has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr` has quit [Remote host closed the connection]
sloanr has joined #commonlisp
alemmens has quit [Ping timeout: 260 seconds]
Fare has joined #commonlisp
Fare has quit [Ping timeout: 260 seconds]
sloanr has quit [Remote host closed the connection]
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 252 seconds]
igemnace has joined #commonlisp
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
mingus has joined #commonlisp
_cymew_ has joined #commonlisp
kenran has joined #commonlisp
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 264 seconds]
mingus1 has joined #commonlisp
semarie has quit [Remote host closed the connection]
semarie has joined #commonlisp
mingus has quit [Ping timeout: 260 seconds]
mingus1 is now known as mingus
rgherdt has joined #commonlisp
pve has joined #commonlisp
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 272 seconds]
seletz has joined #commonlisp
alemmens has joined #commonlisp
masinter has quit [Remote host closed the connection]
Brucio-61 has joined #commonlisp
alemmens has quit [Ping timeout: 246 seconds]
alemmens has joined #commonlisp
scymtym has joined #commonlisp
Cymew has joined #commonlisp
scymtym_ has joined #commonlisp
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 252 seconds]
Brucio-61 has joined #commonlisp
Brucio-61 has quit [Remote host closed the connection]
Brucio-61 has joined #commonlisp
Brucio-61 has quit [Ping timeout: 260 seconds]
Brucio-61 has joined #commonlisp
alemmens has quit [Ping timeout: 252 seconds]
shka has joined #commonlisp
alemmens has joined #commonlisp
alemmens has quit [Ping timeout: 252 seconds]
alemmens has joined #commonlisp
ttree has quit [Ping timeout: 260 seconds]
Cymew has quit [Quit: Konversation terminated!]
Cymew has joined #commonlisp
occ has quit [Ping timeout: 260 seconds]
OlCe has quit [Remote host closed the connection]
scymtym_ is now known as scymtym
Algernon69 has joined #commonlisp
alemmens has quit [Ping timeout: 246 seconds]
marcoxa has joined #commonlisp
<ecraven>
pjb: do you know Garnet? can I write constraints that depend on *other* objects (things like "if the object in my slot `parent' resizes itself, I want to change my size too"?
<ecraven>
)
<pjb>
I tried it a long time ago. I found it nice.
<pjb>
KR (Knowledge Representation) is independent of Garnet. Garnet is built on it. KR is a OO system (different from CLOS). You can use KR to implement your objects with constratins. If you want to use CLOS with constraints, you may consider Cells.
pranavats has left #commonlisp [Error from remote client]
<pjb>
Now, I don't remember the details, but it's possible that it may be possible to merge KR and CLOS stuff. At least, you can write generic functions with methods on both kind of objects.
<pjb>
ecraven: ^
<pjb>
I guess nowadays you would choose CLOS+Cells instead of KR, and use KR only if you want to use Garnet. But it may be a good idea to have a look at KR.
<ecraven>
thanks. just found a tour.pdf and tutorial.pdf for garnet, I'll skim through these. just trying to understand how things work there ;)
<ecraven>
isn't prototype OO just as imperative as it gets? you create objects, modify them, save your image. you have no way of recreating them in the same way, if you lose that image, right?
<hayley>
Prototype objects may be defined by textual form.
<hayley>
The difference, though, is that the text form describes an object and its slots immediately, and not a class. For example, I can write a Self object as (| x = 42. |)
alemmens has joined #commonlisp
<ecraven>
hayley: but in practice, isn't it harder to write reproducible code? (though that might be an issue with image-based languages anyway, not just prototype ones)
<hayley>
I think that is an issue about how you approach persistence, not about prototypes or classes.
<ecraven>
hm.. would prototypes and generic functions work, if dispatch was based on predicates, not "types"?
<ixelp>
specializable/prototype-specializer.lisp at master · sbcl/specializable · GitHub
<ecraven>
hayley: thanks!
<ecraven>
scymtym: thanks!
<pjb>
ecraven: it's harder to write reproducible code, if you code at the REPL. The same difficulty would occur with CLOS. If you type at the REPL: (defclass coo () ()) (defvar *coo-1* (make-instance 'coo)) (defmethod moo ((obj (eql *coo-1*))) 'hi) (moo *coo-1*) --> hi ; how reproducible is that?
<pjb>
ecraven: but if you put that in a file, then it'll be reproducible. Same thing with prototype based OO.
<ecraven>
but doesn't prototype-based OO "invite" this style of work more? because it's so easy to modify objects until "stuff works"
<pjb>
ecraven: if the predicate is (eql obj *coo-1), yes, prototypes and generic functions would still work the same. ;-)
<pjb>
ecraven: how is a javascript script different from a Common Lisp "program"?
<ecraven>
javascript has no history of proper REPL development though
<ecraven>
well, I don't just want to specialize on *one* object, but on predicates of objects (hypothetically ;)
<ecraven>
Interlisp didn't handle that too badly..
<ecraven>
you edit code, and you can "dump" it into a file. the UI remembers where each function goes, and does the right thing ;)
<pjb>
yes. You may also try Interlisp, it's been restored. See #lispm
<ecraven>
pjb: thanks
<ecraven>
rather #interlisp, right?
<pjb>
Yes.
<ecraven>
Thanks to all of you for the information, I'll go and read it :D
<Gnuxie>
ecraven: idk what you mean by JavaScript "has no proper history of REPL development", there's quite clearly a REPL in the browser and it really is necessary to use to do any kind of web dev
alemmens has quit [Ping timeout: 265 seconds]
<ecraven>
Gnuxie: indeed, and I'm not a web developper, so I don't know how the real pros do it, but from my experience that repl is more for "let's see what that function call really does in a browser" and less for "I'll write my program here in this repl", isn't it?
<_death>
indeed.. it's more "edit a file and reload".. where reload is equivalent to killing the image and starting anew
<Gnuxie>
maybe, but people do that in CL when they get into a situation where it is more ergonomic to reload than fix the environment
jeosol has quit [Quit: Client closed]
pranavats has joined #commonlisp
random-nick has joined #commonlisp
<phoe>
which is more of a FUBAR situation than a "every cycle of the feedback loop looks like this" situation
VincentVega has joined #commonlisp
<_death>
often times repl sessions can last for days
<hayley>
I watch over my bot via REPL; at best that means I've had a REPL open for 100 days or so.
<_death>
yes, similarly for my server.. but even on the development machine I sometimes have such sessions.. of course, sometimes I restart tens of times a single day
<VincentVega>
random-nick: Hey, sorry for the late reply, just saw this. I don't really mind holding this discussion anywhere.
<VincentVega>
random-nick: In Fern, I will do configurations and contexts using dynamic inheritance. Even if CLOS could be cajoled to allow that, it wouldn't work because you should be able to apply that to particular objects. Wrt GUIs, there are often a lot of similar entities that different only slightly, and which you might want to be creating at runtime programmatically (or modifying via slot addition/removal). If you are familiar with gamedev,
<VincentVega>
there it can be quite a problem too.
<VincentVega>
random-nick: As per cells vs constraints: multi-way constraints let you do stuff like multi-value unpacking (e.g. #(0 1 2) <--> :x 0 :y 1 :z 2), which is useful for defining synonyms and easy accessors. Multi-garnet also deals with loops, and well, there are quite a few other things to it, really. Cells isn't so bad, but it's not as nearly as capable (not judging, we all do this at times, but the codebase is kind of a
<VincentVega>
random-nick: I see this as a special case of the debate about dynamic typing. I am not arguing about the usefulness of explicit typing, but the case for flexibility is pretty clear-cut.
<VincentVega>
PS sorry about these text dumps. As I said, we can move anywhere you like.
<_death>
hayley: on my server, ps -p `pidof sbcl` -o etime => 309-22:41:58
<_death>
though the server's uptime is 1328 days(!) according to htop
<hayley>
Yes, I don't have a reliable power supply and my last uptime was cut short.
<hayley>
And I also rewrote the bot to pretend to be modular.
<pjb>
(uptime) #| uptime: 1 day, 22 hours, 11 minutes, 43 seconds.↩ --> 166303 |# I had to reboot for a system update 2 days ago…
<_death>
it does mean sbcl is not the most up-to-date, and sometimes (not often, as you can see) that's a reason for a restart
<pjb>
_death: system upgrade are more often reasons to restart (emacs, lisp, etc). Ie. those programs are quite stable!
marcoxa has quit [Ping timeout: 272 seconds]
<_death>
pjb: right, but here's there's also a mismatch between server and development machine, as I keep sbcl and libraries that use sbcl-specific code up-to-date on the latter.. sometimes this creates conflict if I want to update the code on the server
Algernon69 has quit [Ping timeout: 246 seconds]
marcoxa has joined #commonlisp
<_death>
I suppose a different style (the prevalent style, with docker and such) would be to build an image and deploy to server.. repl could still be available, but image restarts would happen more often
alemmens has joined #commonlisp
<pjb>
only when you restart your docker :-)
<_death>
in that style, whenever you want to update the code, you build a new image.. the repl could be used for debugging, but usually not updates
<ecraven>
VincentVega: is there a manual for multi-garnet?
kenran has quit [Remote host closed the connection]
<atgreen>
jackdaniel, cl-indentify worked nicely for me, FYI.
<atgreen>
just give it input and output streams and it formats the code nicely, preserving comments
<jackdaniel>
atgreen: I see, thanks
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
Fare has joined #commonlisp
marcoxa has quit [Ping timeout: 268 seconds]
occ has joined #commonlisp
alemmens has joined #commonlisp
atgreen has quit [Ping timeout: 260 seconds]
<ecraven>
after reading through the (normal) Garnet manual, it is definitely more complex than I had first thought.. but interesting ;) I don't see how this can be implemented in a performant way though...
<ixelp>
Fix a symbol package (!1) · Merge requests · François-René Rideau / fare-matcher · GitLab
VincentV` has joined #commonlisp
atgreen has joined #commonlisp
VincentVega has quit [Ping timeout: 252 seconds]
<VincentV`>
ecraven: At the time of writing KR was actually created as an efficient alternative to the typical frame-based systems of the time. (2) It was fast enough 30 years ago, it will be fast enough now. (3) There will be specialization mechanisms and batch graphical API commands in Fern.
VincentV` is now known as VincentVega
atgreen has quit [Ping timeout: 272 seconds]
<ecraven>
VincentVega: thanks for all the interesting ideas and links ;) regarding fast enough, it'll be interesting to see that, many things have improved, especially expectations ;)
<ecraven>
Full HD at 60Hz is a *lot* of pixels
<jackdaniel>
depends how big is the pixel, mine are 100x100 ;]
<VincentVega>
ecraven: Sure : )
<jackdaniel>
you may draw line going through any three points if the line is thick enough
<VincentVega>
ecraven: There will be caching mechanicsms in Fern. If you are interested, take a look at "The Drawing Process" in the Fern section.
<VincentVega>
jackdaniel: some serious pixels you got there : )
alemmens has joined #commonlisp
<jackdaniel>
they are just bold
<jackdaniel>
or hubby if you like
<jackdaniel>
chubby*
<VincentVega>
Chubby isn't quite my game if you know what I mean : )
<pjb>
ecraven: remember that garnet is a GUI; it doesn't have very hard time constraints, notably not on modern hardware. As long as the reaction time is under 10,000,000 ns…
<pjb>
ecraven: of course, using something like KR or Cells may have efficiency implications compared to more procedural systems, but again, you'd use that to avoid having to track the dependencies between the data elements yourself.
puchacz has joined #commonlisp
Lycurgus has joined #commonlisp
<ecraven>
pjb: I'm thinking of things like positioning points based on data, so if the data changes, widgets should move.. think of particle systems in a game. unless the idea is that this sort of approach just isn't suitable to that
<VincentVega>
ecraven: You could wrap a large point cloud into a custom data structure, and then build around that. I don't really see a problem.
marcoxa has quit [Ping timeout: 260 seconds]
<VincentVega>
I mean, sure, of course, if you create some crazy amount of interactive elements, and if you use constraints on all of them, it will probably be troublesome. It depends exactly on what you are doing, too. And, yes, sure, it's yet to be seen how exactly performant multi-way constraints are (but the papers claim good performance for their demos).
cognemo has quit [Ping timeout: 268 seconds]
<Fare>
jackdaniel, I lost my OTP for cl.net... oops. I need to renew access before I may merge.
<random-nick>
VincentVega: don't gamedevs use entity-component-systems instead of prototype OO for such dynamic objects?
marcoxa has joined #commonlisp
<random-nick>
also, it's unclear to me how would layout work, wouldn't child cells have to have some information about where the parent cell is going to put them during laying out?
<VincentVega>
random-nick: Some use protype OO. The point was that the class/object seperation doesn't work there.
<VincentVega>
random-nick: The information may be accessed via pointer variables. There are also contexts.
<random-nick>
and regarding your mentions of climacs, if you're not aware, there's a new in-development rewrite of it called second climacs, but it's still uses a character-based representation afaik (but it no longer uses a custom incremental parser) https://github.com/robert-strandh/second-climacs
<ixelp>
GitHub - robert-strandh/Second-Climacs: Version 2 of the Climacs text editor.
<VincentVega>
random-nick: I knew about 2nd climacs, but not that it decided to ditch the parser. Interesting, thanks.
<beach>
The parser is much better than that of (first) Climacs, though.
<beach>
So it can parse source code that contains uses of reader macros.
<VincentVega>
beach: Yeah, Eclector is an awesome development. Thank you for it, and the people who developed it. I am hoping to reuse it myself when the time comes.
<VincentVega>
* and the other people who developed it
Algernon69 has quit [Quit: Leaving]
<random-nick>
also it's important to note that climacs uses the lisp image it resides in, not a swank connection
<beach>
VincentVega: Oh, I am responsible mostly for the idea. The one to thank is scymtym.
Lycurgus has quit [Quit: Exeunt: personae.ai-integration.biz]
<VincentVega>
Well, thanks to scymtym too, then!
<VincentVega>
random-nick: right, I see.
<beach>
Speaking of which, I am not sure how to handle reader macros in a structure editor.
marcoxa has quit [Ping timeout: 272 seconds]
<ecraven>
mandate custom support code for the structure editor from the macro creator? :D
<beach>
So write the code twice in different ways; in one way for the reader and in another way for the editor?
<random-nick>
VincentVega: and regarding the section about the project management platform, there already exists such an integrated platform implemented in C called fossil (https://www.fossil-scm.org/) and it's used by sqlite and tcl, though it's much stricter than what you want to make. basically, it's a version control system, bug tracker, forum and wiki all stored as a single sqlite database
<VincentVega>
beach: I can't provide a direct link to the particular section, but I wrote about that here https://project-mage.org/the-power-of-structure just search for the "Handling of Reader Macros" section.
<ixelp>
[Project Mage] The Power of Structure (+ Lisp!)
<beach>
VincentVega: Thanks!
<VincentVega>
random-nick: I've heard of fossil, never tried it though. But to me, yeah, the major point is in the environment.
<VincentVega>
random-nick: I should probably mention that, though.
<holycow>
beach, is climacs 2 a structured editor?
<minion>
holycow, memo from pjb: (load "/path/to/your/quicklisp/setup.lisp") in your rc file.
<minion>
holycow, memo from mfiano: it's just a directory so sure, just updated your implementation's startup file to reflect the new location.
<beach>
holycow: No.
<holycow>
k, cool.
<jackdaniel>
it doesn't have a structure then?
<pjb>
It's like emacs, I guess we could write something like paredit for climacs 2.
<VincentVega>
beach: I actually refer to your paper there, it helped understand a few points about reader macros.
<beach>
I see.
<beach>
jackdaniel: What?
<jackdaniel>
beach: it was a joke. if it is not "structured", then...
<beach>
I see.
<jackdaniel>
Great!
<ecraven>
holycow: If you try using paredit (or one of the other similar modes) in Emacs, or watch videos of SEdit, you'll see what structure editors might be like.
<random-nick>
VincentVega: also, as a drawing "backend" you might be able to use the lower parts of mcclim, it might or might not be more comfortable than sdl2 but could be more flexible if you need it
<random-nick>
reading the mcclim critique I thought you misunderstood some parts of clim, but I haven't really written anything with mcclim so I'm not sure
<ecraven>
VincentVega: have you written anything about handling text? that's one of the larger hurdles, imho ;)
<VincentVega>
random-nick: I did misunderstand a point or two. I will have to rearticulate that, I placed a notice there too. As per the backend: all I will want from the backend is some events and draw calls, I think that sdl should do just fine.
<ixelp>
[Project Mage] The Power of Structure (+ Lisp!)
<ecraven>
sorry for not explaining what I mean, I'm talking about unicode and character composition and all that stuff
<ecraven>
ltr and complex fonts and so on
<ecraven>
(well, rtl really, ltr we know anyway)
marcoxa has joined #commonlisp
marcoxa has quit [Client Quit]
<VincentVega>
ecraven: Oh, no, I haven't written anything about unicode or encodings. As per rtl, I think that's where specialized editors could help, because every editor is itself responsible for its own graphical output (and stuff like cursor motion).
attila_lendvai has joined #commonlisp
<VincentVega>
ecraven: I might be misunderstanding, but if you mean a hurdle to structural editing, could you elaborate?
<ecraven>
not to structural editing, but in general. even the structural editor should support entering all kinds of text, right?
OlCe has joined #commonlisp
<VincentVega>
ecraven: Yeah, I have read a few horror stories about the correct handling of various editing situations. But I am convinced that structural editing may only help. What structural editing gives you is knowledge about the information you are dealing with. Structural editors are in essence specialized editors, and so, yes, they can do whatever the information at hand requires them to do. There are no limitations to that.
<ecraven>
something like harfbuzz could do the shaping, then you "only" have to draw the glyphs ;)
<VincentVega>
ecraven: Yeah, that part of the text-handling story, I prefer to leave to stuff like harfbuzz, for now : )
<ecraven>
do you re-implement Multi-Garnet, or use the existing code?
<VincentVega>
ecraven: Definitely reuse.
son0p has quit [Ping timeout: 264 seconds]
<VincentVega>
random-nick and ecraven: thank you both for the interesing questions and the useful pointers, by the way : )
<VincentVega>
I'm still here though, in case there's a desire for more discussion.
alemmens has quit [Ping timeout: 260 seconds]
<random-nick>
regarding my mcclim as a backend point, I was referring to the fact that clim is structured as a tower of abstractions where you can use the lower levels without the higher ones
<VincentVega>
random-nick: Oh, yeah, you mean snatch away some lower layer? Ha, maybe. Who knows.
NotThatRPG has joined #commonlisp
<NotThatRPG>
Using SLIME, should I expect evaluating a special variable in a debugger frame to give an accurate value for that special variable at that point in the stack? I'm getting a NIL where a function called incorrectly *binds* that variable, but I don't see the value set initially at the bottom of the stack. Using SBCL.
<NotThatRPG>
(and yes, I do mean that the variable is *bound* -- not set)
<beach>
It is interesting that the standard is ambiguous when it comes to the word "bound". I would like to fix that some day.
<jackdaniel>
slot-bound-with-safeword-p
<contrapunctus>
lol jackdaniel
<jackdaniel>
NotThatRPG: if you mean the value before the dynamic binding, you may call symbol-value on it
<jackdaniel>
I see, thanks. I must have confused that with something else, because I'm sure I saw something like this..
<random-nick>
I don't think the standard provides a way to access the global value of a special variable?
azimut has quit [Remote host closed the connection]
<beach>
Here is an example of the ambiguity: (defparameter *a* 10) (defparameter *b* 20) (progv '(*a* *b*) '(30) (list (boundp '*a*) (boundp '*b*))) gives (T NIL).
Equill has joined #commonlisp
azimut has joined #commonlisp
<beach>
But the dictionary entry for PROGV says that *b* is "bound" (but "then made to have no value").
<beach>
I would like to fix the terminology so that there is a separation between "bound", i.e., a binding exists, and "having a value".
occ has quit [Ping timeout: 268 seconds]
<beach>
random-nick: I think that's correct.
cognemo has joined #commonlisp
<Catie>
What would it mean for a symbol to be bound, but have no value? Just that BOUNDP would return T?
<beach>
Catie: It means the case illustrated by PROGV, and yes, if BOUNDP were correctly named in that situation, it would return T.
alemmens has joined #commonlisp
<boigahs>
does *b* still evaluate to 20 in that example
<beach>
No.
<beach>
It has no value.
<beach>
And we don't have a term for that situation.
<boigahs>
Ok, I see the relevant part of the spec now.
pranavats has left #commonlisp [Error from remote client]
tyson2 has quit [Remote host closed the connection]
holycow has quit [Quit: Lost terminal]
puchacz has quit [Quit: Client closed]
cage has joined #commonlisp
pranavats has joined #commonlisp
<Bike>
What's the best practice for having custom asdf component types? I remember it being an old problem that defsystem-depends-on doesn't help if your component class names are symbols in some dependent package, but I don't remember the solution.
<jackdaniel>
I don't know what is the best practice however asdf-user is a package that should exist
<random-nick>
aren't component type names keywords?
<jackdaniel>
asdf names its own component types with keys, yes
<jackdaniel>
s/keys/keywords/
<_death>
I remember that problem with cffi grovel.. in the end it was resolved by it too using a keyword
<ixelp>
cffi/asdf.lisp at master · cffi/cffi · GitHub
<etimmons>
Use strings instead of symbols for the component class names. The strings are READ-FROM-STRING after all defsystem-depends-on are loaded.
<phoe>
etimmons: nice
<random-nick>
by the way, I might have asked this question earlier, but how do you generate code and compile it with the file compiler while playing along with asdf?
<random-nick>
do you need to make a separate component type which runs the generator and then uses the result? where do you put the generated file? same place as the system's source files or into wherever asdf keeps the fasls?
<phoe>
random-nick: maybe cl-unicode can provide some help
<ixelp>
cl-unicode/cl-unicode.asd at 2790a6b8912be1cb051437f463400b4a7198748a · edicl/cl-unicode · GitHub
<Bike>
etimmons: nice, thank you. the manual does not seem to describe this...
<random-nick>
hmm, kind of weird? it seems to make a separate system which has additional outputs on load-op, then on the main system it additionally checks whenever all of them are present, and if not, loads that separate system?
<random-nick>
and I guess where to place the additional outputs is handled by asdf? or is it just at the root of the system
<random-nick>
on my installation they seem to be present in the root of the cl-unicode system
puchacz has joined #commonlisp
tyson2 has joined #commonlisp
<phoe>
and that is because they are generated into it
<ixelp>
GitHub - edicl/cl-unicode: Portable Unicode library for Common Lisp
tane has joined #commonlisp
tane has quit [Changing host]
tane has joined #commonlisp
louis77 has joined #commonlisp
<random-nick>
phoe: what seems rather confusing to me is that the generated files seem to have an older modification date compared to the human-written files
arthurlemmens has quit [Ping timeout: 256 seconds]
<random-nick>
phoe: anyway, thanks for the pointers, this seems to work fine since cl-unicode is a very popular package
<phoe>
I know that guix people had to work around it generating source files in its source directory, since source directories in guix are immutable and therefore read-only
puchacz has quit [Quit: Client closed]
<phoe>
but it's trivia (pun intended)
<Bike>
i'm still having a heck of a time understanding checkl. with cl-conspack, even if i try testing with upstream conspack instead of my fork, fiveam says it's not doing anything
puchacz has joined #commonlisp
ChanServ has quit [shutting down]
<phoe>
most likely because there's nothing to be done
<phoe>
after a brief glance I have no idea if the code that invokes checkl via fiveam actually works
<Bike>
i also get some deprecation warnings. maybe i should just port the tests to use fiveam directly.
<phoe>
honestly, I'd do it - even if respecting the principle of least surprise is everything you get out of it
<phoe>
I've read the manual the last time you've mentioned checkl and it still seems too clever for me
<Bike>
alrighty
VincentV` has quit [Ping timeout: 268 seconds]
morganw has joined #commonlisp
arthurlemmens has joined #commonlisp
ChanServ has joined #commonlisp
<NotThatRPG>
beach, jackdaniel : I had to go out before your responses. I was talking to Phoebe and they said that SBCL implements dynamic bindings efficiently using UNWIND-PROTECT, which avoids a lot of the performance issues of specials, but isn't well suited for this kind of debugging use case.
arthurlemmens has quit [Ping timeout: 265 seconds]
<jackdaniel>
NotThatRPG: perhaps a hack in this spirit would work: