<lispmacs>
does anybody know if there is a way in GCL to increase the bind stack size. I have a case of bind stack overflow that does not seem to be a problem with the same code in SBCL
<no-defun-allowed>
All I can suggest is to quit GCL and just use SBCL.
<Xach>
lispmacs: i don't know of anyone who uses gcl, sorry.
<Xach>
i understand there are some appropriate uses but those users aren't here that i know of
<bitmapper>
lispmacs: are you running gcl master?
<pjb>
Well, maximal has been ported to ecl and other CL implementations, so I'm not sure there remains a use fo gcl. At least not until a big effort is made on it.
<ralt>
Oh, maxima uses GCL?
<pjb>
used.
<ralt>
Ah, no longer
<pjb>
now you can use ecl to compile it.
Bourne has quit [Ping timeout: 260 seconds]
EvW1 has quit [Ping timeout: 244 seconds]
shifty has quit [Ping timeout: 265 seconds]
<LdBeth>
Axiom still get better performance using GCL
<LdBeth>
And some Axiom libraries are not going to port to FriCAS because of license
<lispmacs>
bitmapper: Xach: pjb: The wxmaxima 20.03.1 package in Guix uses maxima wih gcl 2.6.12. I didn't personally have anything against gcl, but I was just running into this case
<bitmapper>
lispmacs: bizzare
<lispmacs>
where bind stack overflows
<no-defun-allowed>
I swear I saw Maxima on SBCL once. Maybe on macOS?
<bitmapper>
maxima works fine on sbcl anywhere
<lispmacs>
i altered maxima package definition to use sbcl, and the error went away
<MichaelRaskin>
Nixpkgs defaults to Maxima on SBCL, and I assume this is not a completely unique decision
<lispmacs>
but I was still wondering if gcl had a way to adjust bind stack size. I don't really like to stop using a piece of software just because I run into one error
<lispmacs>
i couldn't find anything on that in the manuals that were installed with it, but maybe I missed something
frodef` has joined #lisp
frodef has quit [Ping timeout: 272 seconds]
<LdBeth>
lispmacs: you might want to check out maxima mailing list archives
<lispmacs>
LdBeth: they are all using sbcl it seems. Maybe that is the answer to my question :)
<LdBeth>
lispmacs: yes, if possible just use sbcl since maxima already dropped gcl seems
<LdBeth>
But some old threads from 2014 have discussed about bind stack overflow issue
<LdBeth>
You can checkout on maxima’s project page on sourceforge
Kundry_Wag has quit [Remote host closed the connection]
<LdBeth>
But usually it means you’re writing wrong code/there’s a bug in maxima than the binding stack limit has been set too low
<LdBeth>
Since the default build setting should work
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<lispmacs>
LdBeth: hmm, yes, I'm thinking that there must be a maxima bug in the code triggering the overflow. Maybe I'll try some code adjustments and see if I can work around it
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
gko has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
jonatack_ has joined #lisp
jonatack has quit [Ping timeout: 265 seconds]
shangul has joined #lisp
abhixec has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
jprajzne has quit [Quit: jprajzne]
karlosz has quit [Ping timeout: 258 seconds]
karlosz has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
sjl has joined #lisp
karlosz has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
bitmapper has quit [Ping timeout: 258 seconds]
wxie has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Lycurgus has joined #lisp
terpri has quit [Remote host closed the connection]
shifty has joined #lisp
terpri has joined #lisp
<karlosz>
should it be foo-toplevel or foo-top-level?
<karlosz>
everything i read seems to be wildly inconsistent
mono has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
terpri has quit [Remote host closed the connection]
monok has quit [Ping timeout: 256 seconds]
terpri has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<Xach>
karlosz: cltl2 has rules that are consistent
<karlosz>
even there, since "top level" is written with a space, you'd expect foo-top-level
<karlosz>
but of course you have things like :load-toplevel, :compile-toplevel
<Xach>
oh, i guess top-level vs toplevel is the thing
<karlosz>
yah
ralt has quit [Quit: Connection closed for inactivity]
jprajzne has joined #lisp
akoana has left #lisp ["Leaving"]
pjb has joined #lisp
troydm has quit [Ping timeout: 256 seconds]
nmg has joined #lisp
notzmv has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<beach>
Good morning everyone!
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<beach>
pjb: A hard question to answer. During bootstrapping, I compile (using the SICL compiler) files containing definitions of macros, normal functions, generic functions, classes, etc. Then I load the compiled files into first-class global environments and the resulting code is executable in the host Common Lisp system (using an interpreter for intermediate code). And I generate native code, but there is no system for that code to
<beach>
execute in yet.
<pjb>
I see.
<pjb>
So basically, it's already usable as a compiler targetting the host CL implementation.
monok has joined #lisp
<beach>
You can say that, yes. I tried turning the intermediate code into Common Lisp code for execution in the host, but the SBCL compiler was unable to handle the size of the resulting code.
<beach>
So I am interpreting the intermediate representation instead.
<beach>
So it means I can test a lot of the SICL infrastructure, including the generation of discriminating functions and such, but I can't test the native-code generator yet.
<pjb>
ok.
<Fare>
beach, SICL is taking shape nicely. Congratulations.
<beach>
Fare: Thanks! Yes, I am very pleased with recent progress.
mono has quit [Ping timeout: 264 seconds]
terpri has quit [Remote host closed the connection]
<beach>
Plus, Bike and karlosz are working on Cleavir compiler optimizations that I have not integrated into SICL yet, but they are part of Clasp now.
terpri has joined #lisp
<beach>
And heisig is working on a very nice implementation of the sequence functions, using sealed classes and generic functions.
<beach>
His functions are portable and they often perform better than the native ones in SBCL.
<beach>
So there is progress on several fronts.
<beach>
And scymtym continues to improve Eclector. It is an extremely useful library module now.
<beach>
Trucler (compile-time lexical environments) is not moving, but appears to be working as advertised. That was also heisig's work.
<beach>
Coming soon: Extraction of first-class global environments into a separate repository, and a version of PRINT-OBJECT that can be customized by the client.
<beach>
Coming a bit later: Separate repository of the Cleavir compiler framework, including the representation of abstract syntax trees and intermediate representation.
<beach>
All those modules are possible to use in order to create a complete Common Lisp implementation. But, most existing implementations can't use them because of the way these implementations are built.
<beach>
The modules often require the full Common Lisp language, and that is incompatible with the way most Common Lisp implementations are gradually bootstrapped from a subset of the language.
<beach>
So at some point, I need to turn the SICL bootstrapping technique into something that can be used by other Common Lisp implementations as well.
<LdBeth>
Congrats, it’s nice to see such a great progress
<beach>
Thanks!
rozenglass has quit [Ping timeout: 265 seconds]
rozenglass has joined #lisp
Kundry_Wag has joined #lisp
mangul has joined #lisp
<LdBeth>
I’d imagine that if SICL can access host lisp’s functions and data it is already ideal to be used for all sorts of code analysis
shangul has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
Bike has quit [Quit: Lost terminal]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<beach>
What kind of analysis are you thinking of?
<beach>
But yeah, the Cleavir-based compiler can be customized, so it can be used to turn source code into an abstract syntax tree, using the macro definitions of your choice, including the host ones, if that is what you prefer.
<beach>
Those macro definitions are just part of a first-class global environment that the compiler works against, so it is even possible to stick (say) ECL macros in such an environment and compile ECL code in SBCL.
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
<LdBeth>
I don’t have exact idea, but it seems possible to be used to develop a distributed computing/compiling environment that multiple instances of lisp can sharing compiling environment via network
<beach>
That sounds possible. But I am not sure what it would be used for. It is also tricky because of compile-time execution, so a lot of sandboxing must be put in place.
wxie has quit [Ping timeout: 244 seconds]
mangul has quit [Ping timeout: 265 seconds]
<beach>
Aside from creating a new Common Lisp implementation (i.e., SICL) using these new techniques, another (possibly futile) objective is to convince maintainers of other Common Lisp implementations to use some of these modules, so as to cut down on the collective maintenance burden.
<beach>
I mean, imagine the possibility of writing compiler optimization passes that will automatically benefit several different Common Lisp implementations.
<LdBeth>
Yes, the probability to have more aggressive opts with configurability to disable or enable by need
jprajzne has quit [Quit: jprajzne]
dddddd has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
_whitelogger has joined #lisp
* Fare
writes a detailed explanation of why the definition of uiop/package cannot be modified, ever.
* Fare
puts that explanation on top of the file uiop/package.lisp
<solrize>
interesting, i hadn't heard of sicl or cleavir before. i didn't realize much new CL stuff was going on
<solrize>
i'd like to try clojure but hate the JVM world so i figured maybe a java-less port would happen sooner or later
<no-defun-allowed>
Oh, I read it the wrong way around.
<phantomics>
ABCL is really slow
<phantomics>
I've found some interesting limitations to it as well
<phantomics>
For instance, it cannot create and use hash tables at compile time (i.e. during macroexpansion)
Bourne has joined #lisp
orivej has joined #lisp
karlosz has quit [Quit: karlosz]
<beach>
solrize: Check the ELS proceedings to get a better idea of what is going on in the Lisp world in general, and in the Common Lisp world in particular.
* beach
guesses that solrize does not habitually attend ELS.
karlosz has joined #lisp
narimiran has joined #lisp
<beach>
We have had 15 SICL-related papers published since 2014, 12 of which in ELS and 3 in ILC.
wxie has quit [Ping timeout: 256 seconds]
<beach>
Actually, some of the papers by heisig are also SICL related, so 15 is a conservative estimate.
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
<Fare>
phantomics, that's a weird limitation. Why can't ABCL use hash tables at compile-time?
<no-defun-allowed>
Do you mean that macros can't use hash tables, or that they can't expand to hash tables?
yankM has joined #lisp
* Fare
notices that mkcl only ships a modified asdf 3.1.7, and can't upgrade from that to 3.3.4
lispmacs has left #lisp ["rcirc on GNU Emacs 26.3"]
pjb has quit [Ping timeout: 272 seconds]
wxie has joined #lisp
<p_l>
beach: there was an ILC since 2013?
* p_l
tries to realign his internal time line
<beach>
2014 I think was the last one.
<p_l>
Just managed to check it, I was previously somehow sent to 2012 when I was looking for last one
<beach>
There was definitely one in 2014, because I attended it. :)
<p_l>
Yep, seen the program now ;-)
jprajzne has joined #lisp
<p_l>
The last one I remember well was in Japan, somehow I recalled the "Lisp on the Move" but for 2014 but not that it was ILC
<p_l>
(I've never been to any ILC)
<beach>
I was also at the one in San Francisco in 2002. I didn't have any papers to present, but moore33 (Tim Moore) presented McCLIM there. And that's when I invited him to come spend a year in Bordeaux. He is still living here. :)
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
srazzaque has joined #lisp
mibr has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
yankM has quit [Ping timeout: 260 seconds]
<Fare>
2014 was the last one, in Montreal. p_l would you organize the next one?
<p_l>
Fare:
<p_l>
Fare: I don't have that much time on my hands :(
<p_l>
and we first need to get rid of the pandemic, cause if I were organizing, I'd prefer an on-site one
jprajzne has quit [Quit: jprajzne]
<beach>
Fare: I have a small(!) improvement to ASDF to suggest. I need for it to use first-class global environments, so that I can tell it in which environment to compile and load things. Could you do that for me, please? :)
heisig has joined #lisp
<beach>
I guess that won't work anyway will it. The host system would have to have a compiler that takes first-class global environments as well.
<beach>
Oh, well!
FreeBirdLjj has joined #lisp
jprajzne has joined #lisp
holycow has joined #lisp
orivej_ has quit [Ping timeout: 256 seconds]
holycow has quit [Client Quit]
wxie has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
<solrize>
i've never been to ELS but pictures i've seen of Lisp events tend to look like Forth Day. ;)
pjb has joined #lisp
<p_l>
solrize: how so?
_whitelogger has joined #lisp
<no-defun-allowed>
morniiiiiiing phoe
astronavt has quit [Quit: ...]
<beach>
Hello phoe.
<solrize>
p_l, forth day always looks like a gandalf convention :)
astronavt has joined #lisp
<Fare>
beach, I'm not sure what API you're thinking of.
<Fare>
beach, (within-my-environment (asdf:load-system :foo)) ?
<Fare>
beach, of course it's even worse, because the reader has to know about the environment to properly intern the symbols in the sub-forms.
<beach>
That would be one possibility: (with-environment (env) (asdf:...))
astronavt has quit [Remote host closed the connection]
<beach>
Fare: Eclector is programmable, so it can be configured to do that.
<phoe>
I assume that WITH-ENVIRONMENT is going to take care of programming the reader
<Fare>
what would trigger the magic behavior, though?
<Fare>
how does the reader know it's for immediate evaluation, vs just a constant list '(with-environment ...) ?
astronavt has joined #lisp
<beach>
It doesn't have to. Interning things is the same in both situations.
<Fare>
what changes?
dmc00 has quit [Remote host closed the connection]
<beach>
The compilation environment and the run-time environment.
astronavt has quit [Remote host closed the connection]
<beach>
... as specified by the Common Lisp HyperSpec.
<Fare>
aha, some kind of generalized cross-compilation?
<phoe>
beach: isn't this ASDF's :around-compile?
<beach>
Er, no, not necessarily. It is already in the standard.
<Fare>
The Historical Documents! (Never give up, never surrender)
<phoe>
this allows one to set up dynamic environment around the process of compiling an ASDF component
<beach>
I think I need to be able to redefine compile-file and load as well.
<beach>
Because the host versions of those typically do not take environments into account.
sdumi has quit [Ping timeout: 264 seconds]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
<beach>
But I don't know whether ASDF calls COMPILE-FILE and LOAD directly. I guess if ASDF can be programmed to use a different compiler and loader I would be fine.
mathrick has quit [Quit: Leaving]
<Fare>
beach, ASDF always calls them via the LOAD* and COMPILE-FILE* helpers in UIOP/LISP-BUILD.
<beach>
Oh! Wonderful!
<Fare>
But then again, there can be ASDF extensions that don't.
astronavt has joined #lisp
<beach>
I'll check it out!
<beach>
Thanks!
<beach>
If that works out, I can use ASDF for my SICL bootstrapping process.
astronavt has quit [Remote host closed the connection]
<Fare>
(never called by ASDF itself, though used while debugging it)
<beach>
Hmm, and not generic.
<Fare>
not generic?
<beach>
COMPILE-FILE* is not a generic function.
<Fare>
should it be? Dispatching on what?
<beach>
A first-class global environment. :)
<beach>
Seriously, how would I go about using a different version of COMPILE-FILE and LOAD?
<Fare>
also, you are not authorized to change the signature of any function in UIOP, except in backwards-compatible ways (e.g. adding a keyword argument). But you can create a new function with a new name, and write a shim to preserve the old interface.
<beach>
Sure.
jprajzne has quit [Client Quit]
<beach>
I'll just go look at the ASDF source code.
astronavt has joined #lisp
orivej has joined #lisp
<Fare>
same goes for any function in ASDF that may be called while performing an ASDF plan.
jprajzne has joined #lisp
<beach>
All I need is for ASDF to call my own version of those two functions.
<Fare>
You can use the usual ADVICE mechanism and/or re-roll your own.
<phoe>
can't see a possibility to do that without rewriting chunks of UIOP
<beach>
OK.
orivej_ has quit [Ping timeout: 265 seconds]
<Fare>
One good thing about UIOP and ASDF: all functions are NOTINLINE, so intercepting them should always work.
<beach>
Fare: Actually what we are doing in several libraries now, like Eclector and Trucler, is that the protocol functions trampoline to a generic function, passing it the value of the library-defined *CLIENT* variable. Pre-defined methods of those generic functions do not specialize on the client parameter.
<beach>
That way, client code does (let ((library:*client* (make-a-client))) (library:...))
<beach>
And clients can then create its own primary or auxiliary methods on the generic functions.
<beach>
I think ASDF would be a primary candidate for that technique.
<phoe>
that would work, except the lambda lists are immutable
<beach>
phoe: I am not expressing myself very well.
jprajzne has quit [Quit: jprajzne]
<beach>
phoe: Assume you have a protocol function like COMPILE-FILE with the lambda list (FILE).
jprajzne has joined #lisp
<beach>
phoe: It would trampoline like this: (defun compile-file (file) (generic-compile-file *client* file))
<beach>
So client code can do (defmethod generic-compile-file ((client my-client-class) file) ...)
<beach>
There is no modification of any lambda list here.
<beach>
Clients who don't need to customize anything can just use the protocol functions.
<beach>
They provide a reasonable default behavior.
<beach>
Like (defmethod compile-file (client file) (cl:compile-file ...))
<beach>
Sorry.
<beach>
Like (defmethod generic-compile-file (client file) (cl:compile-file ...))
<beach>
phoe: Does that make sense?
jprajzne has quit [Client Quit]
pjb has quit [Ping timeout: 272 seconds]
jprajzne has joined #lisp
Kundry_Wag has joined #lisp
<beach>
phoe: Oh, and your condition-system library might use this mechanism too.
jonatack_ has quit [Read error: Connection reset by peer]
mangul has joined #lisp
<beach>
solrize: Looks fine to me.
<solrize>
thx
<beach>
One thing though, in Common Lisp, the convention is for END to mean a position one beyond the last element of stuff.
terpri has quit [Remote host closed the connection]
<beach>
As in :start :end of the sequence functions.
<beach>
That way, the length of the interval is always (- end start).
<solrize>
yeah ok i'll change that
<solrize>
python uses that convention too
terpri has joined #lisp
Bourne has quit [Read error: Connection reset by peer]
<beach>
And two intervals s1,e1 and s2,e2 can be concatenated if and only if e1 = s2.
doesthiswork has quit [Ping timeout: 272 seconds]
<beach>
And the LOOP keyword BELOW is there to help with such situations.
<beach>
So you don't have to do (loop ... to (1- end) ...)
shka_ has joined #lisp
<solrize>
loop for i from start below end?
<beach>
Yeah.
<phoe>
beach: it looks fine
<beach>
phoe: Good.
rgherdt has joined #lisp
<solrize>
fixed, and also fixed a parenthesis error thanks
<beach>
Sure.
orivej has quit [Ping timeout: 256 seconds]
<solrize>
what are people doing in CL "for real" these days?
* beach
figures SICL is not "real". Oh, well.
<solrize>
well SICL is another CL implementation... i meant applications. something similar happens in forth, where everyone who gets interested in it writes a forth interpreter ;)
<beach>
solrize: Does McCLIM and its applications count?
<solrize>
what is that?
<solrize>
McCLIM - A powerful GUI toolkit for Common Lisp aha
<solrize>
it sounds cool
<no-defun-allowed>
beach: "Having asked about the possibility that there are real people out there who use LISP (as opposed to AI People who are known to be non-real) and having received no answers, I can only conclude that LISP is not being used and that it is not, therefore, a real language." ~ the closing announcement for a section of Lisp Pointers
<beach>
It is an implementation of the standard called Common Lisp Interface Manager.
<beach>
no-defun-allowed: Heh, nice!
<solrize>
no-defun-allowed, AI counted as an answer in the 1980s-90s but i think CL is not being used in AI very much any more. is that wrong?
<no-defun-allowed>
solrize: My university will (poorly) teach me Lisp in an AI context next year, so does that count?
<solrize>
i guess that counts ;). anything that isn't itself a CL implementation or CL dev tool counts
<beach>
solrize: In the past, I worked on an interactive editor for music scores. Version 1 shows that my ideas work, but it doesn't look great, and I made some incorrect design decisions. I don't have time to work on version 2, but jackdaniel is planning to work on the GUI for it, using McCLIM of course.
<no-defun-allowed>
I think RavenPack uses Lisp in an AI context as well for analysing "unstructured data" like news reports as well.
<no-defun-allowed>
(Buy one "as well", get one free...)
<solrize>
no-defun-allowed, that is cool, it sounds like old school lisp doing natural language stuff
<solrize>
i think a lot of people use python and nltk for that now
<beach>
Most people use languages other than Common Lisp for most stuff.
<solrize>
true ;)
<beach>
And not necessarily for good reasons.
<no-defun-allowed>
Myself, I work on a kind of distributed object system that I think is the most distributed of them all (though I might be biased).
<beach>
So we can't really take inspiration from them.
<no-defun-allowed>
solrize: I was going to say "Oh, so Python and a C library", but nltk is actually written in Python. I have a hunch it would be quite slow and wouldn't scale to however much data that company processes.
<solrize>
that's possible, i dunno. i thought maybe they use nltk to extract statistics from the data, then dump it all into a GPU neural net or something. i haven't looked at it though. i should, since NL is an interest of mine
<no-defun-allowed>
(One nice thing is that code written for the average Common Lisp library has a shelf life of longer than a few months, which I can't say for any programs that use TensorFlow.)
<solrize>
haha true
<solrize>
you see they weren't satisfied with breaking the python language in the python 2 to python 3 downgrade, so now they're trying to break the standard library as well?
<solrize>
PEP 594 i think
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
<no-defun-allowed>
I guess that's something that takes a while when some libraries are effectively part of the language, sure.
narimiran has quit [Ping timeout: 258 seconds]
<solrize>
one thing i like about CL is that it resists doing stuff like that
<solrize>
i guess that means it is frozen though
<beach>
Not really, since you can program the compiler by writing macros. That's not possible in other languages. There you have to wait for a new standard.
jprajzne has quit [Client Quit]
<no-defun-allowed>
All the stuff is there in CL that you would need to write performant libraries, and S-expressions don't "penalise" you for using your own operators.
<solrize>
it sounds hard to change CL to a lisp-1 by writing macros :)
jprajzne has joined #lisp
<solrize>
or to replace strict evaluation with lazy :)
pjb has joined #lisp
<beach>
Sure, and it would be hard to turn it into C as well.
<solrize>
yep :
<no-defun-allowed>
In this case, we are talking about the "corroded batteries" that come with Python has for some extinct formats, which are all modules of functions.
<solrize>
i used CL a little in the 1990s and stuff still works about like i remember
<solrize>
i was never a lisp wizard though
<solrize>
wisp lizard
<Fare>
beach: is that some sort of context-oriented programming?
frodef` has quit [Ping timeout: 256 seconds]
<Fare>
or subject-oriented?
<beach>
Fare: Good question. I haven't thought about it philosophically; only pragmatically.
pve has joined #lisp
orivej has joined #lisp
<no-defun-allowed>
(Side note on corroded batteries: I wonder why the reaction to having :host and :version among other "extinct" parameters to MAKE-PATHNAME is "Why the hell do we have those in Common Lisp?", not "Why the hell don't I have those on my computer?" Having those in the filesystem sounds quite handy.)
jprajzne has quit [Quit: jprajzne]
<Fare>
no-defun-allowed, don't get me started on pathnames.
<no-defun-allowed>
I suppose I shouldn't.
<phoe>
Fare: it sounds much more like plain old dependency injection™
<Fare>
phoe, nah that would be just plain old special variables.
<phoe>
where the file compiler right now is the hardcoded cl:compile-file, but it might as well be foo:compile-file
sdumi has joined #lisp
jonatack_ has joined #lisp
jprajzne has joined #lisp
jonatack_ has quit [Client Quit]
jonatack has joined #lisp
v88m has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
phoe: So, I assume that in your library you use special variables for things like adding handlers and restarts. What I would like to see is the use of this CLIENT mechanism so that I can change that, since I would prefer to use specific entry types in the dynamic environment, rather than special variables.
FreeBirdLjj has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
ralt has joined #lisp
<phoe>
beach: yes, I understand that
orivej has joined #lisp
<beach>
phoe: For instance, HANDLER-BIND could call INVOKE-WITH-HANDLER with the CLIENT object and the default mechanism would be to use a special variable, but it could be customized then.
<phoe>
beach: sure, I can do that - tell me how to access and augment your dynamic environment object and we can do that
<beach>
NO, NO. The point is that you don't have to do anything other than using this mechanism.
<phoe>
beach: *oh*
<phoe>
you just become a client on it inside SICL
<phoe>
s/on/of/
<beach>
Client code would stick a method on INVOKE-WITH-HANDLER, specialized to their client class.
<phoe>
I see
<beach>
But you need to publish and document the generic protocol, of course, so that clients can adapt it properly.
FreeBirdLjj has quit [Ping timeout: 272 seconds]
<beach>
phoe: No rush of course. You should do the book first.
<beach>
But it would be interesting to see how your library could be generalized this way.
dale has quit [Quit: My computer has gone to sleep]
<phoe>
beach: correct, I can imagine that. I'll do that when my book is no longer something I need to pay attention to.
<beach>
Then I could use it with no modification, and just customization instead.
<phoe>
(and oh gods I already long for that moment)
Kundry_Wag has joined #lisp
<beach>
The wait is finite. Be brave!
sdumi has quit [Ping timeout: 265 seconds]
<Fare>
phoe, at first I didn't see why your talk even mattered, and then I understood that it has something deep to say about designing language features for extensibility.
v88m has joined #lisp
<Fare>
and I wondered -- what is (if any) the relationship between your condition-system-on-CL and SICL's condition system?
Kundry_Wag has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
I think phoe's portable-condition-system is going the SICL condition system, last I heard.
<beach>
Fare: SICL doesn't have one yet. I am planning to use phoe's.
<phoe>
Fare: the condition code I wrote is planned to be integrated as SICL's condition system someday
<phoe>
woah, three people's already a crowd
<phoe>
but, yes, basically, that
<phoe>
I think that throughout my voyage I found the major pain points where the standard CL condition system is *not* extensible or programmable
<phoe>
does it matter for end users? I guess no, not really, they usually don't need to dabble with such matters
<phoe>
but when they actually do need to... then, ouch
<beach>
Another reason for Common Lisp implementations to use yours.
<phoe>
likely they'll do that only if there's a pretty good use case for that that outweighs the costs of decoupling the old condition system, integrating mine, and paying the maintenance and performance costs
pjb has quit [Ping timeout: 272 seconds]
<phoe>
and these are all non-trivial
<Fare>
some day, when I have time, I'd like to somehow port SICL to Gerbil. Maybe with a modular way to embrace or not embrace some CL features, if I figure out how to do that.
orivej_ has joined #lisp
<phoe>
I think you have a lot more wiggle room when you design an implementation from scratch, which is the case for SICL, but this isn't the case for implementations that have grown organically over the time and have a lot of history of that organic growth - which is, like, all fully functional CL implementations nowadays.
<beach>
Fare: Sounds good to me. But I think you should wait until things are stable.
<Fare>
(e.g. integration with Gerbil's module system vs symbols and packages a la CL)
<beach>
phoe: Indeed.
<Fare>
(hopefully, both would be available at the same time)
<beach>
phoe: So if SICL ever becomes as high performance as existing implementations, that means that SICL will have a much lower maintenance cost for the same performance.
orivej has quit [Ping timeout: 256 seconds]
<Fare>
(so with minimal amount of wrapping, you could access CL from Scheme, and Scheme from CL)
<Fare>
(obviously, more wrapping is needed when you deal with NIL vs #f '() nil)
<phoe>
beach: correct, we're still a while from that moment though
<phoe>
that's why I said, all fully functional CL implementations *nowadays*
<Fare>
#f '() nil (void) (values) ... Scheme is the Lisp that wanted to be ML.
<phoe>
Fare: this smells dangerously close to: 0 "" NaN null undefined false
yankM has joined #lisp
emacsomancer has quit [Read error: Connection reset by peer]
anticrisis has quit [Quit: Leaving]
<SAL9000>
reminds me of perl's "0 but true" values
orivej has joined #lisp
orivej_ has quit [Ping timeout: 258 seconds]
<SAL9000>
e.g. if you call an external program via system() and use the return value -- the exit status -- as a boolean, 0 will be "true" because that's "success"
<phoe>
Fare: but then again, the *original* idea for my talk was, to quote a famous non-existent researcher, "Science isn't about «why», it's about «why not»?"
<phoe>
so I just explored the idea and talked about what I found. I literally created a solution that is looking for problems - and it's good that SICL happened to be one such problem
<phoe>
plus, it was a very good exercise in pushing the condition system to its portable limits
emacsomancer has joined #lisp
remix2000 has joined #lisp
remix2000 has left #lisp [#lisp]
<phoe>
so, summing all the reasons for the talk, we have 1) because-we-can-ism, 2) spreading knowledge about the functioning of the condition system, 3) possibility to integrate condition/exception systems of CL + other languages (possibly also CL) that have a common compilation target (possibly also CL), 4) SICL adopting the portable condition system, 5) checking how far we can push the CL standard in regard to the
<phoe>
condition system
amerlyq has joined #lisp
<phoe>
all in all, I guess that's a decent collection of reasons
<phoe>
s/in regard/with regard/
<Fare>
phoe: there's a Jeff Goldblum meme about (1).
<phoe>
Fare: what is it?
<phoe>
;; also, I really expect (1) to be a meme by now, especially since in my case (1) came from a quote from the late Cave Johnson of Aperture Laboratories
<SAL9000>
"We do what we can, because we must!"
<phoe>
SAL9000: hold on for a second, that quote doesn't sound right
<SAL9000>
yeah, I just looked it up and realised it was wrong...
<phoe>
Fare: thankfully my research did not bring dinosaurs back from the dead
<Fare>
whoa, what do you think the Common Lisp Condition System is?
<phoe>
Fare: I think we can all bear the consequences of my research existing, contrary to the research of the Jurassic Park
<SAL9000>
phoe: "Science isn't about WHY. It's about WHY NOT. Why is so much of our science dangerous? Why not marry safe science if you love it so much. In fact, why not invent a special safety door that won't hit you on the butt on the way out, because you are fired."
<phoe>
Fare: ...touché
<SAL9000>
the CL condition system is more of a bird than a dinosaur... it's still alive and useful :-)
<SAL9000>
s/alive/around/
wxie has joined #lisp
liberliver has joined #lisp
<shka_>
phoe: i would like a pet dinosaur so not sure about the thankfully part
mangul is now known as shangul
<solrize>
hey beach is this gauche? (defun iota (start end)
<solrize>
(LOOP FOR i FROM start BELOW end COLLECTING i))
orivej has quit [Ping timeout: 256 seconds]
<solrize>
i.e. upcasing the keywords
<solrize>
some forthers do that
<beach>
Yeah, that would be considered ugly.
<solrize>
thx
orivej has joined #lisp
<phoe>
some people in Lisp upcase T and NIL
<beach>
People would look at the date of your code and expect 40 years ago at least.
<solrize>
yeah they also used to say LISP :)
<phoe>
I don't really understand the problem that it solves, but I don't mind it
<no-defun-allowed>
Sometimes people put : before LOOP keywords, as their editors will render those in a different colour.
<solrize>
what, th upcasing? it's like syntax highlighting
<solrize>
oh you can use : ? i'll try that
<beach>
Check out the first edition of Winston & Horn, 1981 for instance.
<phoe>
solrize: loop keywords don't care which package they are read from
<no-defun-allowed>
I don't do that myself, because I don't really have a problem with reading LOOP.
<solrize>
i don't see different coloring in slime after adding the colons, but they make the keywords stand out more, which is good
<Shinmera>
phoe: I upcase constants, T and NIL are just the most prevalent constants.
<solrize>
i had originally called the parameters of that function "from" and "to" but that looked really confusing
<phoe>
Shinmera: oh! I see
<no-defun-allowed>
(Putting : before a LOOP keyword causes it to read as a keyword, which is a different concept, and LOOP will accept LOOP keywords from any package.)
<phoe>
solrize: (let ((from 0) (to 10)) (loop for i from from to to collect i))
<beach>
Wow, second edition from 1984 also uses upper case for code.
<solrize>
phoe yep
<solrize>
is collect the same as collecting?
<beach>
Yes.
<solrize>
k
<beach>
sum and summing too
<solrize>
thx
<beach>
ywlcm
<phoe>
it was a really weird experience to see beach post "ywlcm"
<phoe>
but, well
<beach>
phoe: I am being sarcastic.
<beach>
Sometimes I say: I recommend you do M-x define-global-abbrev<RET>thx<RET>Oh, thank you very much<RET>
* no-defun-allowed
was once ywlcm-ed many moons ago
<beach>
By me?
<beach>
Heh!
<no-defun-allowed>
Yes.
<beach>
no-defun-allowed: But you are a quick and thorough learner.
<no-defun-allowed>
Apparently so.
toorevitimirp has quit [Quit: Konversation terminated!]
<no-defun-allowed>
(From memory, I came in #lisp one day asking for someone to eye over cl-decentralise1, and explained it was an attempt at writing a distributed networking system, and then I went off about how it was written because I was annoyed everyone wrote programs with centralised semantics, then "glued" distribution atop it, then ending up with some technical debt and having to rewrite a great portion of the program. You said
<no-defun-allowed>
that was an interesting observation, I said "ty beach", and you said "ywlcm"...maybe.)
<beach>
Sounds right.
<no-defun-allowed>
Fun times.
<beach>
:)
<no-defun-allowed>
I used to rant a bit more; but then I had a conversation with another #lisp participant whom taught me a lot about distributed programming, so I like to think it wasn't very embarrassing.
mwgkgk has quit [Quit: Connection closed for inactivity]
<beach>
Embarrassment is an integral part of the learning process. Think about learning a foreign language, for instance.
<no-defun-allowed>
Very true.
<beach>
People who do everything they can to avoid being embarrassed don't learn very much. Those are dangerous people.
sugarwren has joined #lisp
<shka_>
no-defun-allowed: bit about the centralized being marketed as distributed hit me hard
<shka_>
i am personally forced to work on a project like this
<shka_>
and what a stinking heap of crap it is
* jackdaniel
gently nudges towards #lispcafe
<jackdaniel>
I've been told that I'm not very gentle with maintaining the channel on-topic, so I've added a word "gentle" to avoid this accusation!
<shka_>
right
<shka_>
sorry for that
<jackdaniel>
no worries
sdumi has joined #lisp
<no-defun-allowed>
jackdaniel: Maybe you should write the book "A gentle introduction to the #lisp topic"
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
Bourne has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
srji_ has quit [Quit: leaving]
orivej has joined #lisp
srji has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
jprajzne has quit [Quit: jprajzne]
terpri has quit [Remote host closed the connection]
shangul has quit [Ping timeout: 265 seconds]
SGASAU has quit [Remote host closed the connection]
pjb has joined #lisp
SGASAU has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
ralt has quit [Quit: Connection closed for inactivity]
dddddd has joined #lisp
orivej has joined #lisp
jonatack has quit [Quit: jonatack]
wxie has quit [Ping timeout: 272 seconds]
kpoeck has joined #lisp
elflng has quit [Ping timeout: 256 seconds]
karlosz has quit [Quit: karlosz]
pjb has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
McParen has joined #lisp
jprajzne has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
Bourne has quit [Read error: Connection reset by peer]
quazimodo has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
jprajzne has quit [Quit: jprajzne]
toorevitimirp has joined #lisp
ayuce has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
pjb has joined #lisp
orivej has joined #lisp
random-nick has joined #lisp
nmg has quit [Ping timeout: 256 seconds]
ayuce has quit [Read error: Connection reset by peer]
rogersm has joined #lisp
ayuce has joined #lisp
rogersm has quit [Client Quit]
arpunk has joined #lisp
ayuce has quit [Remote host closed the connection]
frodef` has joined #lisp
ayuce has joined #lisp
heisig has quit [Quit: Leaving]
v88m has quit [Ping timeout: 265 seconds]
scymtym_ has joined #lisp
ljavorsk has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
pjb has quit [Ping timeout: 246 seconds]
scymtym_ has quit [Remote host closed the connection]
v88m has joined #lisp
scymtym has joined #lisp
Bourne has joined #lisp
terpri has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
sz0 has joined #lisp
ljavorsk has quit [Ping timeout: 272 seconds]
heisig has joined #lisp
troydm has joined #lisp
pjb has joined #lisp
ayuce has quit [Remote host closed the connection]
ayuce has joined #lisp
shangul has joined #lisp
ebrasca has joined #lisp
pjb has quit [Ping timeout: 265 seconds]
Bike has joined #lisp
keepzen has joined #lisp
ebrasca has quit [Remote host closed the connection]
ebrasca has joined #lisp
bitmapper has joined #lisp
ralt has joined #lisp
lemoinem has quit [Killed (beckett.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
cosimone has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
pjb has joined #lisp
Josh_2 has joined #lisp
EvW has joined #lisp
gko_ has joined #lisp
gko has quit [Ping timeout: 258 seconds]
doesthiswork has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
dmc00 has joined #lisp
pjb has quit [Ping timeout: 244 seconds]
orivej_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
RedMallet has joined #lisp
toorevitimirp has joined #lisp
<phoe>
Is there something like a visual S-expression editor? Something that will allow me to explore S-expressions by double-clicking them and edit slots of the browsed objects.
<phoe>
I'm thinking a Lisp inspector except with more visuals, possibly showing tree structure.
Bourne has quit [Read error: Connection reset by peer]
jw4 has quit [Read error: Connection reset by peer]
toorevitimirp has quit [Remote host closed the connection]
jw4 has joined #lisp
<scymtym>
McCLIM's rewritten Clouseau is kind-of like that. it can display certain pieces of information as graphs or trees and does so by default in a few cases. it is also possible to add custom ways of displaying objects. that said, clouseau is not suitable for editing source code
<phoe>
I don't really want to edit source code; I want more of a simple spreadsheet sort of thing.
<phoe>
Or rather, sigh. It's hard to convey visual ideas to text.
orivej has quit [Quit: No Ping reply in 180 seconds.]
<jackdaniel>
Xach: it emerges from zpb-ttf package (open-font-loader -> load-post-info -> load-post-format-2
<jackdaniel>
)
<jackdaniel>
ah, "nooo" says that you already know that
<phoe>
he thought I'd paste the contents of the font file into irc
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
narimiran has joined #lisp
pjb has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
SAL9000 has quit [Quit: Host going down for maintenance.]
orivej_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
<pve>
phoe: could you convert to org mode and edit that, and then convert back to s-exp?
Kundry_Wag has joined #lisp
<phoe>
pve: what do you mean, convert a s-expression into org mode?
<pve>
into a text file that looks like an org file
<pve>
obviously it places some constraints on the s-exp..
<pve>
and depends on how interactive you need it be
<pve>
might not be a good fit
whiteline has quit [Ping timeout: 258 seconds]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
pjb has quit [Ping timeout: 265 seconds]
orivej_ has quit [Ping timeout: 265 seconds]
liberliver has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
keepzen has quit [Quit: Connection closed for inactivity]
luni has joined #lisp
EvW has quit [Ping timeout: 256 seconds]
shangul has quit [Ping timeout: 272 seconds]
gravicappa has joined #lisp
whiteline has joined #lisp
<scymtym>
Xach: i think i know why zpb-ttf cannot load the font
astronavt has quit [Quit: ...]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
<phoe>
scymtym: what is it?
astronavt has joined #lisp
shangul has joined #lisp
<scymtym>
the font has "sparse" indexing and unreferenced extended glyph names in the "post" table. zpb-ttf assumes "dense" indexing and therefore makes and populates an incomplete vector of extended glyph names which leads to the out-of-bounds access when one of the larger indices is processed
<scymtym>
the fix is easy but i'm still looking for a non-messy way to do it
<phantomics>
Drop a message if you need help running it, I'm rebuilding part of the core and haven't paid much attention to the UX lately
<phoe>
phantomics: OK, thanks!
Bourne has joined #lisp
holycow has joined #lisp
<scymtym>
(ql:quickload :clouseau) (clouseau:inspect (find-class 'double)) is one way
<scymtym>
or (cluseau:inspect … :new-process t) to not block your REPL
<scymtym>
*clouseau
<phoe>
"There is no class named SB-ALIEN:DOUBLE."
* phoe
learns to read before pasting stuff into the REPL
<scymtym>
yeah, sorry, FLOAT or whatever
rumbler31 has quit [Read error: Connection reset by peer]
<scymtym>
i was trying to give you an example in which the super and subclass graphs would look nice
<phoe>
yes, I got it
terpri has quit [Remote host closed the connection]
abhixec has quit [Quit: leaving]
<phoe>
scymtym: it's nice! (I broke it though by trying to use the "Back" command)
pjb has joined #lisp
frgo has joined #lisp
<scymtym>
phoe: yeah, there are some pending changes to fix the "history" thing
<phoe>
scymtym: thanks.
ark has quit [Ping timeout: 265 seconds]
ark has joined #lisp
yankM has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
gareppa has joined #lisp
gareppa has quit [Client Quit]
gareppa has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
gareppa has quit [Remote host closed the connection]
kpoeck has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
sdumi has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
dddddd has quit [Ping timeout: 240 seconds]
asarch has joined #lisp
astronavt has quit [Quit: ...]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
sirmacik has joined #lisp
rogersm has joined #lisp
rogersm has quit [Client Quit]
Oladon has joined #lisp
EvW has joined #lisp
kpoeck has joined #lisp
dmc00 has quit [Ping timeout: 264 seconds]
elflng has joined #lisp
gko_ has quit [Remote host closed the connection]
gko has joined #lisp
gravicappa has quit [Read error: Connection reset by peer]
gravicappa has joined #lisp
gravicappa has quit [Read error: Connection reset by peer]
gko has quit [Ping timeout: 256 seconds]
shangul has quit [Ping timeout: 256 seconds]
paul0 has joined #lisp
gravicappa has joined #lisp
gravicappa has quit [Read error: Connection reset by peer]
SGASAU` has joined #lisp
SGASAU has quit [Remote host closed the connection]
RedMallet has quit [Quit: WeeChat 2.6]
heisig has quit [Quit: Leaving]
rippa has joined #lisp
bmansurov has quit [Quit: 👋]
gravicappa has joined #lisp
gravicappa has quit [Read error: Connection reset by peer]
bmansurov has joined #lisp
bmansurov is now known as Guest42923
gravicappa has joined #lisp
duuqnd has joined #lisp
nullheroes has joined #lisp
Oladon has quit [Quit: Leaving.]
luckless has joined #lisp
Kundry_Wag has joined #lisp
astronavt has joined #lisp
constptr has joined #lisp
constptr is now known as egemutu
Kundry_Wag has quit [Ping timeout: 240 seconds]
astronavt has quit [Client Quit]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
egemutu is now known as varsbhat
astronavt has quit [Remote host closed the connection]
asarch has quit [Quit: Leaving]
SGASAU` has quit [Remote host closed the connection]
montxero has quit [Remote host closed the connection]
nalik891 has quit [Quit: Leaving]
SGASAU has joined #lisp
varsbhat has quit []
sugarwren has quit [Ping timeout: 260 seconds]
PuercoPope has joined #lisp
<phoe>
Fare: what is the way of extending ASDF with a new operation? Is it possible to have things like a forward-referenced operation in a DEFSYSTEM form?
karlosz has joined #lisp
shifty has joined #lisp
<phoe>
if I wanted to, say, :perform (ci-test-op (o c) (...)) in an ASD file, is it possible to have ASDF notice that the operation CI-TEST-OP is not defined yet, and therefore create a stand-in in form of a forward referenced class of some sort?
<phoe>
It obviously makes it impossible to invoke the CI-TEST-OP operation; but the benefit is that such ASDF forms will compile.
<PuercoPope>
phoe: instead of a new OP I think it would be better for the runners of test frameworks to support a mode where they terminate the process with the proper exit code instead. It is the same operation after all.
<phoe>
PuercoPope: yes, that's the alternative - we just discussed it elsewhere
<phoe>
I'm just checking how forwards-compatible ASDF is.
<phoe>
There's a lot said about ASDF backwards compatibility, but I haven't yet seen much about the other direction
vaporatorius has quit [Remote host closed the connection]
orivej_ has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
amerlyq has quit [Quit: amerlyq]
McParen has left #lisp [#lisp]
gravicappa has quit [Ping timeout: 258 seconds]
mibr has quit [Quit: mibr]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
dmc00 has joined #lisp
Kundry_Wag has joined #lisp
duuqnd has quit [Remote host closed the connection]
Kevslinger has joined #lisp
mathrick has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
mathrick has quit [Remote host closed the connection]
mathrick has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
rgherdt has left #lisp ["Leaving"]
sdumi has quit [Read error: Connection reset by peer]
dddddd has joined #lisp
<Fare>
phoe: you can refer to a class by symbol in :in-order-to specifications and component-depends-on methods, if that's what you mean.
<Fare>
so, yes, that's a modicum of forward-compatibility.
<phoe>
Fare: let's suppose that ASDF 3.6 defines a new standard operation, ASDF:CI-TEST-OP. How can I add information about this new operation to a DEFSYSTEM form that will also not break it for current versions of ASDF?
<phoe>
...I was hoping to avoid reader conditionals
shifty has quit [Ping timeout: 265 seconds]
<jackdaniel>
wasn't defsystem-depends-on meant to address concerns of such extensions?
shifty has joined #lisp
choegusung has joined #lisp
choegusung has quit [Client Quit]
<phoe>
hmm
<phoe>
we could, in theory, define an ASDF system that defines CI-TEST-OP if it is not already defined, and use it in DEFSYSTEM-DEPENDS-ON
* phoe
thinks
<jackdaniel>
if asdf had its own reader (because it claims that asd files *are not* lisp source files), you could have used your-system:foobar from your yet-to-be-defined system
<jackdaniel>
but despite not being lisp source file, they strangely are
orivej_ has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
<Fare>
phoe, the best way is to define a subclass of system that has the fields you need.
shifty has joined #lisp
<Fare>
you don't need #+asdf3.6 in your :in-order-to as long as the present actions don't depend on future actions.
<phoe>
Fare: it's not an issue of missing fields, it's an issue of referencing operations before they are defined
<Fare>
asd files ARE lisp source files, to be read in a specific context different from the context used for regular lisp files.
<phoe>
the only field I need is :perform but :perform does not accept symbols that do not (yet) name concrete operation classes
<Fare>
phoe, that's what symbols as operation designators are for.
<Fare>
what about using :defsystem-depends-on to ensure the class exists before it's used?
<phoe>
Fare: I'll need to to exactly that
<jackdaniel>
I'd expect that if my system "foo" defsystem-depends-on bar, which defines operation bar:xyz, then I could use bar:xyz operation in foo
sdumi has joined #lisp
<phoe>
I'll need to define that operation class and use :DEFSYSTEM-DEPENDS-ON
<Fare>
the only issue might be if you want the package for your operation class to be defined as part of this defsystem-depends-on.
<jackdaniel>
sure, why would you depend on that system otherwise?
<jackdaniel>
well, I can think of a few reasons
<Fare>
Then a small patch to ASDF might allow you to use strings as symbol designators in :perform specifications as well as in other places in defsystem.
<jackdaniel>
but this one is valid too
<Fare>
It's possible that for now you might have to (load-system "bar") as a prelude to the (defsystem ... :perform (bar:bar-op ...))
<Fare>
because you can't specify :perform ("bar:bar-op" ...) or something.
<Fare>
I'm sure that a patch to ASDF to support the latter would be accepted... just a bit too late for your current project.
arpunk has quit [Remote host closed the connection]
<Fare>
but ASDF certainly teaches patience... I've had a branch waiting for approval for 5 years.
renzhi has joined #lisp
efm has quit [Ping timeout: 258 seconds]
<phoe>
whose approval
<phoe>
or rather
<phoe>
okay, forget that I asked
* phoe
goes to sleep for tonight
orivej has quit [Quit: No Ping reply in 180 seconds.]
antepod has joined #lisp
antepod has quit [Client Quit]
orivej has joined #lisp
Codaraxis has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
Jeanne-Kamikaze has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karayan has quit [Remote host closed the connection]
karayan has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
Lycurgus has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fourier has joined #lisp
anticrisis has joined #lisp
<ralt>
so, unit tests
<ralt>
what's the framework to use those days? 5am? prove?
<ralt>
I don't care much, just need to pick one, so would rather go with the most popular one
<aeth>
prove is broken for me now, in some private side thing where I had been using it 5+ years ago
<aeth>
I think it now requires colors in SLIME or something?