amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123 has quit [Ping timeout: 255 seconds]
kpoeck has quit [Ping timeout: 246 seconds]
random-nick has quit [Ping timeout: 246 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
random-nick has joined #commonlisp
Lord_of_Life has joined #commonlisp
<pillton>
defaultxr: Right. I'm not sure I agree with using M-. for that. I wonder if you can use SLIME presentations to add a menu option when you right click on a symbol or one of your instances?
<defaultxr>
i'm not familiar with slime presentations tbh, i'd have to look into that
cammie has quit [Quit: issued !quit command]
yitzi has quit [Quit: Leaving]
<defaultxr>
personally i think M-. makes perfect sense if i'm able to add the instance as a definition in the M-. list without overwriting any variable or function source locations in the process. but to each their own
sp41 has quit [Quit: leaving]
<_death>
well, the menu already has Find Definition
<_death>
so if, say, sb-introspect:find-definition-source were a generic function, and you had a nice interface to generate a method like in https://plaster.tymoon.eu/view/2545#2545 ...
<defaultxr>
yeah, it being a generic function would be ideal (though i'd of course prefer a solution that works on more implementations than just sbcl)
<defaultxr>
(and on sly too, not just slime)
random-nick has quit [Quit: quit]
sjl has quit [Quit: WeeChat 2.2-dev]
<_death>
there is also (swank:ed-in-emacs '("/home/death/tmp/foo.lisp" :position 77)) I guess
<_death>
(which, if you apply a small patch to have it return true, can be added to sb-ext:*ed-functions* so you can use cl:ed ;)
cjb has quit [Ping timeout: 246 seconds]
<defaultxr>
true, i could probably use that, though i was hoping for something that would better integrate with M-. since i think that is in more common use than cl:ed
flip214 has quit [Ping timeout: 272 seconds]
igemnace has joined #commonlisp
char has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
flip214 has joined #commonlisp
Bike has quit [Quit: Lost terminal]
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 255 seconds]
Josh_2 has quit [Remote host closed the connection]
<beach>
Good morning everyone!
<cheers>
good morning!
<beach>
Hello cheers.
rt has joined #commonlisp
robin has quit [Ping timeout: 256 seconds]
rt` has joined #commonlisp
rt has quit [Ping timeout: 255 seconds]
cmack has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 240 seconds]
<kakuhen>
I have stumbled on yet another CCL bootstrapping problem, and it's way beyond my knowledge and understanding
<kakuhen>
while I was able to successfully bootstrap 1.12.1 from 1.12 on FreeBSD/amd64, Linux is giving me problems (with the same computer) when I attempt loading the bootstrap image
<kakuhen>
I'm getting dropped into the lisp kernel debugger in the middle of loading some streams fasl -- even though I received no warnings or errors when compiling ccl or the level-0 files
<beach>
Maybe someone should rethink CCL bootstrapping, just like it was done for CMUCL.
taiju has quit [Ping timeout: 255 seconds]
taiju has joined #commonlisp
<kakuhen>
the documentation notes that it should be (in theory) possible to compile ccl from another cl implementation, but such a process is experimental and not officially supported
<kakuhen>
in any case, i should probably just be happy with the binaries i'm already provided -- the bootstrap attempt was more of an exercise to see if I could do it on linux, since the distribution I'm on does not offer any official packages for CCL, but it does for ECL
<beach>
kakuhen: rme told me that, while it would be possible to make it so that CCL can bootstrap from other Common Lisp implementations, "it is probably not worth the effort to make it happen" [or something to that effect].
akoana has quit [Quit: leaving]
<moon-child>
that is a shame
<beach>
I think some day I need to turn the SICL bootstrapping procedure into an implementation-independent library, so that it can be used by other implementations too. But I currently have absolutely no idea how to do that.
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 246 seconds]
akoana has joined #commonlisp
^[ has quit [Read error: Connection reset by peer]
^[ has joined #commonlisp
srhm has quit [Remote host closed the connection]
derelict has quit [Ping timeout: 240 seconds]
tophullyte has joined #commonlisp
char has quit [Ping timeout: 255 seconds]
akoana has quit [Quit: leaving]
akoana has joined #commonlisp
lisp123 has joined #commonlisp
robin__ has joined #commonlisp
rt` has quit [Ping timeout: 246 seconds]
akoana has quit [Quit: leaving]
dsk has joined #commonlisp
shka has joined #commonlisp
gioyik has quit [Quit: WeeChat 3.1]
rgherdt has joined #commonlisp
amb007 has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
MichaelRaskin has quit [Remote host closed the connection]
<beach>
Looks interesting. I'll watch it later. I am not sure how relevant it is to Common Lisp bootstrapping, though. I guess I'll find out. I mean, SICL bootstrapping is already pretty "meta".
<beach>
The first few phases of SICL bootstrapping can be seen as building a circular graph of classes (MOP classes and other essential classes) and generic functions (again MOP and other essential functions). And we do that by using the standard tools like DEFCLASS, DEFMETHOD, DEFCLASS, DEFUN, DEFMACRO, etc.
<pjb>
beach: each meta-level has its own environment, and processes the lower level.
<pjb>
I imagine that a first step to bootstrap an implementation, is being able to implement and run it inside another implementation.
<beach>
Exactly.
<beach>
That's taken care of with first-class global environments and the AST evaluator.
<pjb>
So in your current system the standard tools are the meta level for the new (bootstrapping) level.
<beach>
I am not sure about this "level" approach, though.
<pjb>
Is it not implied by your various bootstrapping phases?
Cymew has joined #commonlisp
<beach>
I don't see that as levels, no. Each phase is merely meant to make the object representation different. First, we use host objects, then bridge objects, and finally ersatz objects.
<beach>
There are no "levels" in the sense of limited functionality or expressiveness in any level.
<pjb>
But perhaps having those bootstrapping phases is only an artifact of the development process. I mean, what would prevent to use the current implementation to generate everything of the new implementation completely independently of the current environment, in one single phase?
<beach>
So the problem I solve is the following: If I do something like "make-instance" in the host, it will create an opaque host object. But I need to do that in order to create some SICL classes like T, standard-object, etc.
pillton has quit [Quit: ERC (IRC client for Emacs 27.2)]
<beach>
I then make a new MAKE-INSTANCE etc. that creates instances of those classes that have slots that SICL needs.
<beach>
But they are till host instances, though no longer host classes.
<pjb>
Yes, because you want to re-use the same source in different contexts.
<beach>
Then I define a new MAKE-INSTANCE that take those funny non-host-classshes and create more SICL-like objects called ersatz objects.
<pjb>
But instead, you could just generate a binary that will have a single make-instance in the new image.
<beach>
Oh, I do.
<beach>
Or, rather, I will.
<beach>
All this discussion is just for creating the initial object graph. No binary yet.
<pjb>
Yes. I understand the step-by-step approach you use, but as a development/learning/testing process.
<pjb>
Ultimately, it could be done in a single step.
<pjb>
Anyways; off to work, now. Have a good day!
<beach>
The steps are not important as you point out, but I need several different first-class global environments, each one containing objects represented in a different way. And I need three different such representations.
<beach>
You too.
pve has joined #commonlisp
<beach>
So I naturally divided the bootstrapping procedure into three (plus a few more for initial and final stuff) phases, each phase creating objects with a different representation in a different first-class global environment.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
rhett has joined #commonlisp
rhett has quit [Excess Flood]
treflip has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
joeyxl has joined #commonlisp
joeyxl has quit [Quit: Quit]
joeyxl has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
hendursa1 has joined #commonlisp
joeyxl has quit [Remote host closed the connection]
hendursaga has quit [Ping timeout: 244 seconds]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 255 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
lisp123 has joined #commonlisp
cmack has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 268 seconds]
pjb has quit [Read error: Connection reset by peer]
kevingal has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
selwyn has joined #commonlisp
lisp123 has quit [Ping timeout: 240 seconds]
lisp123 has joined #commonlisp
<Devon>
Anyone know a source compare tool superior to unix diff?
<Devon>
contrapunctus: Delta is merely "A viewer for git and diff output" like emacs diff-mode.
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<Devon>
contrapunctus: Emacs ediff is merely "a comprehensive visual interface to diff & patch" so neither of them actually differs from unix diff.
CrashTestDummy2 has joined #commonlisp
<Devon>
Delta and ediff could be front ends to something better than diff.
CrashTestDummy3 has quit [Ping timeout: 246 seconds]
<splittist>
Devon: on what dimension(s) are you measuring superiority?
attila_lendvai has quit [Read error: Connection reset by peer]
lisp123 has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
lisp123 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<Devon>
splittist: LOL, oh, more like what I'd've written myself.
<Devon>
splittist: smarter choices of where to split hunks.
lisp123 has quit [Ping timeout: 252 seconds]
kakuhen has quit [Quit: Leaving...]
<splittist>
Devon: smarter by having knowledge of the underlying semantics of the string? Absolutely. The trick would be to make a tractable way to specify the various edit operations and their costs. I do sometimes wonder if speed is all that important for actual human-readable texts.
random-nick has joined #commonlisp
random-nick has quit [Client Quit]
random-nick has joined #commonlisp
kevingal has quit [Remote host closed the connection]
lonzo has joined #commonlisp
pjb has joined #commonlisp
lisp123 has joined #commonlisp
Cymew has joined #commonlisp
<jmercouris>
how come (write 'salmon :stream nil) still shows up in my REPL?
<jmercouris>
I would expect it to show up once, but not twice...
<jmercouris>
AKA the return value of the function
<jmercouris>
but not the printing of 'salmon
<jmercouris>
I would have thought that any stream other than t would result in it not printing
<jmercouris>
also with regards to the previous discussion, there is a diff tool that works with SEXP
<polygon-op>
when stream is specified as nil, then it defaults to the standard output
<jmercouris>
son of a potato, I should have read the CLHS more carefully
<jmercouris>
thanks polygon-op
<polygon-op>
I suppose that it could be written differently, i.e (defun write (object &key (stream-p nil stream) …) ) and act based on the fact whether stream-p is true
<polygon-op>
on the other hand nil is not a valid output stream designator
<polygon-op>
(handling nil is a feature of the function format)
<jmercouris>
which is why I thought to pass in nil actually
<jmercouris>
sneaky tomatoes
<jmercouris>
s/tomatoes/language developers
<jmercouris>
sorry, typo
<polygon-op>
neither makes sense to me
<jmercouris>
oh, that's OK :-)
<jmercouris>
it doesn't matter anyway
<jmercouris>
I'm just being silly
<scymtym>
what you expected (write … :string nil) to do is basically the function WRITE-TO-STRING
cage has joined #commonlisp
<jmercouris>
is "TOMATO" the same as TOMATO?
<polygon-op>
s/[:]string/[:]stream/
<jmercouris>
It's a rhetorical question of course
<polygon-op>
please stick to the channel topic
<jmercouris>
I'm sorry you weren't able to connect the dots
<scymtym>
polygon-op: right, thanks
<jmercouris>
I was pointing out that (WRITE-TO-STRING 'tomato) -> "TOMATO"
<jmercouris>
which is not the same as (write 'tomato)
<scymtym>
i'm confused. shouldn't the comparison be with (with-output-to-string (stream) (write 'tomato :stream stream))? i thought that was the intended behavior
<jmercouris>
I'm actually working on a different problem, not interested in writing a string
<polygon-op>
it should, that's just lack of understanding the difference between the return value and the stream output ,) /me carries with his day
<scymtym>
but what is the desired behavior if it is neither returning a string nor writing to a stream?
leo_song has quit [Remote host closed the connection]
Bike has joined #commonlisp
Posterdati has quit [Ping timeout: 252 seconds]
Posterdati has joined #commonlisp
leo_song has joined #commonlisp
attila_lendvai has quit [Remote host closed the connection]
makomo has joined #commonlisp
attila_lendvai has joined #commonlisp
derelict has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
yitzi has joined #commonlisp
raeda has joined #commonlisp
raeda has quit [Client Quit]
waleee has quit [Ping timeout: 255 seconds]
treflip has quit [Quit: bb]
PinealGlandOptic has quit [Quit: leaving]
Lycurgus has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
attila_lendvai has quit [Ping timeout: 268 seconds]
CrashTestDummy2 has quit [Ping timeout: 255 seconds]
selwyn has quit [Remote host closed the connection]
selwyn has joined #commonlisp
leeb has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
<beach>
It seems like someone could write a PDF viewer in Common Lisp as a nice project. My evince has crashed four times today from a segmentation fault.
<shka>
sounds horrible
<shka>
enince used to be good
<beach>
Yeah.
<shka>
last time i used it was during the gnome 2 days
<shka>
but i hand no complains
<shka>
*had
<beach>
I can't for my life understand why someone would write something like Evince in C/C++, which is apparently what it is written in.
<shka>
C
<shka>
or could be vala actually
<polygon-op>
beach: if I may suggest - you could use atril which is evince fork (from before gnome 3)
<polygon-op>
it is fairly stable
<beach>
polygon-op: Thanks!
<shka>
okular from kde also works fine, but installing it bloats the system because KDE
* polygon-op
keeps quiet about his dissatisfaction with gnome embracing javascript :)
<shka>
yes, evince is written in C
<beach>
But I would like to see applications like this written in Common Lisp to avoid problems like this.
<beach>
Since such applications are already fairly large, it is no problem if the executable contains a full Common Lisp system.
<shka>
mmm, i would rather see a complete web browser in lisp
<shka>
but this would be an monumental task
<beach>
And these applications are generally useful, not only as part of a Lisp OS, so people can just go ahead and write them.
<beach>
shka: Let me say this again, even though I have said it several times. I think with Common Lisp, there is no need to create a "complete web browser". We could create library modules for the different tasks that a web browser does, like render HTML, render OGG/vorbis, render different video formats, etc.
<beach>
shka: So we can go ahead an create a "web browser" that makes use of the modules we already have, and that uses existing C or C++ modules where we don't have any.
<shka>
on the one hand, yes
<beach>
Then we can little by little migrate different modules to Common Lisp.
<shka>
on the other, i really with that there was a way to control the damn JS using restarts for instance
<shka>
or be able to hook into the html rendering by injecting mixins into the object representation of the html structure
<shka>
in general, i wish that the browser was hackable
<beach>
Either way, I don't think the need for a "complete web browser" eliminates a need for a document viewer, an editor for music scores, a layout program for printed circuit boards, a movie player, a music player, a figure editor, etc.
<shka>
no, my remark is that i don't really need hackable document viewer, i just need it view documents and not be a pain in the ass ;-)
<beach>
So, let me again urge people to start writing such application in Common Lisp so that we can avoid these crashes and other nasty behavior. No need to wait for a Lisp OS to get started.
<shka>
anyway, have a good afternoon
<beach>
Me? Thanks! No reason not to. You too!
<shka>
oh, one thing
<shka>
regarding snippets you were mentioning earlier
<beach>
Yes? Do you want to discuss those in #sicl maybe?
<shka>
since it is also used in the context of the call site optimization, i think it would be a good idea to use fully qualified names when mentioning it
<shka>
beach: i honestly thought that i am on sicl :D
<shka>
(mentioning it in the documentation)
<beach>
What kind of "fully qualified names" do you mean?
<shka>
for instance "debugger snippet" vs "call site optimization snippet"
<beach>
Ah, OK. Thanks!
<shka>
i am not an expert, but i think it can be confusing
<shka>
anyway, bye!
<beach>
Bye.
rogersm has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
varjag has joined #commonlisp
amb007 has joined #commonlisp
Faed has quit [Remote host closed the connection]
yitzi has quit [Quit: Leaving]
lisp123 has joined #commonlisp
<contrapunctus>
Would there be any value in making an implementation-independent static analyzer for Common Lisp code?
<contrapunctus>
(In the spirit of Emacs Lisp Static Analyzer?)
minion has quit [Remote host closed the connection]
specbot has quit [Remote host closed the connection]
lisp123 has quit [Quit: Leaving...]
lisp123 has joined #commonlisp
minion has joined #commonlisp
specbot has joined #commonlisp
<Bike>
i think beach's editor project is supposed to include this kind of capability
azimut has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 272 seconds]
jeosol has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<jcowan>
What is an "analyzer"?
<jcowan>
Is it supposed to do one job, like type checking, or a whole bunch of jobs, like `lint`?
<Bike>
judging by the readme for the emacs lisp static analyzer, it's a pickier compiler without the code generation part, so more like the latter
Alfr has joined #commonlisp
<jcowan>
Classic lint would look for known bugs, generate style warnings, warn about easily abused constructions (like fallthrough between clauses without a /*fallthrough*/ comment, etc.
<jcowan>
Here's a cool example from Fortran:
<aeth>
not really popular because compilers tend to catch that, although they're hidden in the most common build process unless you :verbose t your QUICKLOAD
<jcowan>
DO 120 J=1,256 is a beginning-of-loop statement, where the body extends to the line numbered 120 and J is iterated between the given values.
<Bike>
it could be nice to have such things on-line in an editor, and without the additional complications of actual code generation
<aeth>
yeah, but C-c C-k compilation is typically so fast that I can see why that's not a priority
<aeth>
(per-file recompile will catch most things)
<jcowan>
But if you type a period for the comma, an easy mistake, the compiler sees this as DO120J = 1.256 and makes no complaint.
dsk has joined #commonlisp
<jcowan>
Lint for Fortran, on the other hand, will warn if it sees something like this because it does not ignore spaces, unlike the compiler which is required to do so.
derelict has quit [Ping timeout: 252 seconds]
tophullyte has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
tophullyte has quit [Quit: Leaving]
dsk has quit [Ping timeout: 240 seconds]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<pve>
etimmons: Hey, can I bug you about ASDF a bit?
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Ping timeout: 258 seconds]
Devon has quit [Quit: ERC (IRC client for Emacs 27.2)]
Devon has joined #commonlisp
Devon is now known as Devon7
<contrapunctus>
aeth: I thought only SBCL caught type errors at compile time?
Devon7 is now known as Devon
MichaelRaskin has joined #commonlisp
<aeth>
contrapunctus: In context, it's more about SBCL's STYLE-WARNING/NOTE functionality rather than its (fairly limited) type checking
<aeth>
(most NOTEs are hidden at default optimization levels, though)
nature has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 255 seconds]
clos-encounters has joined #commonlisp
lisp123 has joined #commonlisp
rogersm has quit [Quit: Leaving...]
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
Fade has joined #commonlisp
cuz has joined #commonlisp
isekaijin has quit [Ping timeout: 252 seconds]
isekaijin has joined #commonlisp
kpoeck has joined #commonlisp
kpoeck has quit [Client Quit]
kpoeck has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
<etimmons>
pve: Sure, I'll do my best to help!
<etimmons>
(Just got back from running errands)
aeth_ has joined #commonlisp
aeth has quit [Killed (NickServ (GHOST command used by aeth_))]
aeth_ is now known as aeth
lisp123 has quit [Ping timeout: 265 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Lycurgus has joined #commonlisp
dsk has joined #commonlisp
waleee has joined #commonlisp
gin has joined #commonlisp
<gin>
Is there an equals function to compare two alists?
<White_Flame>
depends on what its contents are
<White_Flame>
but EQUAL would traverse the cons cells
<moon-child>
(assuming you want to deal with the associations being in different order)
<White_Flame>
yeah, do ((a . 1) (b . 2)) and ((b . 2) (a . 1)) compare "equal" in your idea?
<White_Flame>
and then there's ((a . 1) (a . 2)) vs ((a . 1) (a . 3)) which both return the same value for key A
<gin>
I don't need to deal with associations being in different order right now. I will use "equal" for now.
<gin>
thanks moon-child
<gin>
thanks White_Flame
<moon-child>
White_Flame: then you could (remove-duplicates :key #'car :from-end t)
<White_Flame>
yep
karlosz has joined #commonlisp
lisp123 has joined #commonlisp
<pve>
etimmons: great!
<pve>
etimmons: I'm playing around with making a very simple asdf extension that just loads files in alphabetical order. It works fine, except it can't detect when a file has been added or deleted (unless I use :force t).
<pve>
etimmons: I have written the code that scans the directory for changes, but it's not clear to me how I should hook it up to asdf.
<pve>
etimmons: My first thought was to run the code in operation-done-p for compile-op, but then I thought maybe I should define a new operation scan-components-op and have compile-op depend on it.
lisp123 has quit [Remote host closed the connection]
<pve>
etimmons: Do you happen to have any thoughts on when/where this directory scan should take place?
lisp123 has joined #commonlisp
<pve>
etimmons: I ask because you mentioned wanting to do this yourself for you own extension.
<etimmons>
pve: I haven't looked at it yet, but I think the place to hook in would be the define-op for the system
<etimmons>
maybe an operation-done-p method that checks the current list of files against a cached list in the system?
<pve>
mmhmm that's interesting
<etimmons>
That's certainly going to be my first approach when I try it out with my stuff
<pve>
the manual doesn't mention define-op, is it new?
<etimmons>
maybe
<etimmons>
It might have been part of fare's work on multi-phase builds
<pve>
are you going to define a separate operation class?
<pve>
like scan-op or something?
<etimmons>
I wasn't planning on it. But that might be a nice way of doing it
<etimmons>
It would require that I get more comfortable with the multi-phase stuff though
<pve>
I understand ASDF has some kind of cache where it stores the results of operations. I was wondering if I get caching for "free" if I define a new op
tyson2 has joined #commonlisp
<pve>
because ideally I want to scan only once per call to asdf:load-system
<etimmons>
Since that scan-op would need to be performed before the plan for the load-op is computed
<pve>
ohh right, the plan
<pve>
forgot about that
<etimmons>
yeah, that's why I was going to see if I could get away with hacking operation-done-p first.
<etimmons>
I think that should still be cached, so ASDF will only call it once per session
<pve>
and have a cache inside the module instance?
<etimmons>
But I could be wrong
<pve>
oh
<etimmons>
yeah
<pve>
Ok well this was helpful, I'm going to experiment some more. Thanks a lot!
<etimmons>
yep! Let me know what insights you have from your experiments!
<pve>
will do
Lycurgus has quit [Quit: Exeunt]
jeosol has joined #commonlisp
clos-encounters has quit [Ping timeout: 255 seconds]
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
<jeosol>
etimmons I just got out of a rabit hold chasing bazel, bazelisp for parallel compilation of my project. Not sure you remember, we had a discussion over from reddit chat (that you said you weren't initiaally aware it had a chat option)
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<etimmons>
yep, yep!
kpoeck has quit [Ping timeout: 246 seconds]
<etimmons>
How is that going? I sadly haven't gotten a chance to look more at poiu yet :(
<jeosol>
etimmons no worries for not having time. I may have to go back to hackig the poiu
<jeosol>
I haven't looked at it personally, but now that I fully understand the requirements of bazel and bazelisp (for large orgs, 200+, need lots of machines, etc), and so many issues (from others that used it for non C++ or non Java projects),
<jeosol>
I think I'll drop it for now
<jeosol>
by 200+ above, I mean developers
<jeosol>
I plan to start taking a look again at the repo I cloned a while back, may be get it to work for current SBCL
<etimmons>
Yeah, that's not too surprising. Bazel seems like a massive beast to tame.
<etimmons>
I'm pretty sure bazelisp is used internally by Google, so hopefully it wouldn't have tooooo many issues
<etimmons>
I haven't looked at it myself in a very long time, but I also imagine it may not be the most portable thing if that's important to you.
<jeosol>
ok, but I thought you have to use bazel and bazelisp together. I could not get the former to install. I admit I don't understand how these systems are integrated. I was trying to download bazel to test the C++ tutorial
<etimmons>
Oh yeah, my understanding is that bazelisp and bazel go hand in hand
<jeosol>
I have dome some research, and I am mistaken, to think it was something simple, I could just drop in to do my parallel builds. But that is not the case
<etimmons>
And by portability I meant across CL implementations
<jeosol>
It also requires huge amount of memory to run and you often need many machines to really get the benefits
<jeosol>
Yeah, portability is important, but I have only developed in SBCL from the start
<jeosol>
I think bazelisp only works with SBCL
<etimmons>
I forget if it had happened yet when we last talked, but SBCL has gotten rid of the lock around compile-file.
<etimmons>
would be interesting to see if just using plain old threads to compile things would work
<jeosol>
hmm - that's interesting
<etimmons>
would definitely be easier and more portable than poiu's forking model
<etimmons>
Although not as nifty
<jeosol>
I have heard the forking model mentioned frequently - this is a bad design?
<jeosol>
I have been in touch with Fare, the author, on possibly resurrecting this in some fashion, but I'd have to spend time to study the internals
<etimmons>
Hmmm, I think it got released in 2.1.4, but I see no mention of it in the release notes
^[ has quit [Ping timeout: 240 seconds]
<etimmons>
Ha, depends on who you listen to
cuz has quit [Ping timeout: 255 seconds]
^[ has joined #commonlisp
<etimmons>
It's super nifty since it creates a new process that's ~identical to the first. Some application servers use it to, for example, load all the code, do any other expensive startup things, and then be able to spawn workers with nearly zero cost
<etimmons>
but it takes great care to use correctly and can easily lead to dead locks or other unforeseen complications
kakuhen has joined #commonlisp
<etimmons>
ECL had an issue on MacOS where spawning a new process (nominally fork() then exec()) caused streams to get corrupted in the parent process if the exec() failed (e.g., the executable didn't exist)
<etimmons>
Plus, forking doesn't work on all OSes (like Windows)
^[ has quit [Ping timeout: 255 seconds]
Inline has quit [Remote host closed the connection]
akoana has joined #commonlisp
dsk has quit [Ping timeout: 252 seconds]
^[ has joined #commonlisp
Inline has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 272 seconds]
tyson2 has joined #commonlisp
jfb4 has joined #commonlisp
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
rgherdt has quit [Ping timeout: 258 seconds]
pve has quit [Quit: leaving]
lisp123 has joined #commonlisp
karlosz has quit [Quit: karlosz]
lisp123 has quit [Ping timeout: 246 seconds]
<jeosol>
etimmons Thanks for explaining that
Lycurgus has joined #commonlisp
nature has quit [Quit: Lost terminal]
selwyn has joined #commonlisp
joeyxl has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
Alfr is now known as Guest4628
Guest4628 has quit [Killed (calcium.libera.chat (Nickname regained by services))]