amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<shka>
hayley: yeah, i could, but honestly, it is just a matter of closing FD in the right place
<shka>
so it would be easier to pass stream on the thread closure
<shka>
instead of file path
pve_ is now known as pve
dsk has quit [Ping timeout: 272 seconds]
elderK has quit [Quit: Connection closed for inactivity]
alphapapa[m] has joined #commonlisp
Viking667 has joined #commonlisp
jimka has quit [Ping timeout: 245 seconds]
<Viking667>
Good morftervening, wanted to ask a question about Clozure CL. Anyone up for it?
<beach>
Just ask an you will find out.
victor has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
victor has joined #commonlisp
<Viking667>
lol, right. I should have known that. Anyhow, I've just followed the instructions at the github, I was wanting to know what I need to put and where, now that I have lxcl64 and the image... do I need to copy just that to the final destination, or do I need to copy the sourcetree too?
jimka has joined #commonlisp
<beach>
I guess pjb would know that, but he might be busy with his day job.
<Viking667>
lol, that's what was said over on #emacs
<pve>
Viking667: I think you can just run it from wherever
<Viking667>
Ahhh, so that's the instructions there...
<pve>
Viking667: I have a ccl folder somewhere in my home directory, and symlink the lx86cl64 to ~/bin
<Viking667>
okay, cool. Thanks.
<Viking667>
I think I stuck a ccl64 script into my ${HOME}/bin suitably edited to point to my installation
<Viking667>
All right, I think that's all I needed to know at least for now.
<pve>
Viking667: A script will work too, but it is not necessary. A symlink to the binary is enough.
<Viking667>
I'll probably be running it from inside emacs anyhow
jimka has quit [Ping timeout: 272 seconds]
<beach>
Viking667: Yes, you should run it with SLIME.
<Viking667>
meh, SLIME. Haven't run into that much yet.
<beach>
It is pretty much needed for any level of productivity when you develop Common Lisp code.
<shka>
yes
<shka>
otherwise you would have a level productivity of non-interactive language without IDE
<shka>
so let's say editing python files in notepad
<Viking667>
hm, so not like Smalltalk at all, then.
<Viking667>
(or at least, not like most Smalltalks)
<beach>
Viking667: Smalltalk is mainly a "programming system", whereas Common Lisp is a "language" with several different implementations. Most implementations define only a terminal-based text interface. SLIME supplies many more interactive functions that will work with most Common Lisp implementations.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has joined #commonlisp
hendursa1 has joined #commonlisp
gaqwas has quit [Ping timeout: 268 seconds]
jimka has joined #commonlisp
<shka>
that being said, smalltalk and cl are both interactive by design
<shka>
just different routes to the same destination
hendursaga has quit [Ping timeout: 244 seconds]
santiagopim has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
nirnam has joined #commonlisp
jimka has quit [Ping timeout: 256 seconds]
<kakuhen>
Viking667: if you want to go really overboard with a launching script, here's what I have http://0x0.st/-JAI.sh
<kakuhen>
just make sure you change CCL_DEFAULT_DIRECTORY to the appropriate one for your machine.
<Viking667>
hm, doesn't look that different from the one I have.
<pjb>
Yes, if you don't put the ccl directory (with sources, etc) in a place where the ccl64 script expects it, you have to set the environment variable CCL_DEFAULT_DIRECTORY ; or, instead of symlinking ccl64, you can make a copy and edit it.
lsip123_win10 has joined #commonlisp
<lsip123_win10>
Hi - does anybody have any good guides or tips when it comes to logging (for now I am planning on using log4cl, and adding logging features via :before :after etc for generic functions)
<shka>
lsip123_win10: not a bad plan imho
<shka>
but sometimes you may want more fine grained control
<lsip123_win10>
shka: I was thinking of writing my own functions to do that control, but it seems like I might need to pass in variables (to track for example how many times a recursive function has been called) to do that
<lsip123_win10>
is that what you mean (having to append the available data to log with additional data from outside the functions)?
<kakuhen>
regarding counts: what's wrong with tracing functions again?
<kakuhen>
i was in a situation where i wanted to see if a specific method was being called exactly twice and a simple trace suffices
<lsip123_win10>
kakuhen: I have some very deep nesting, think 1000s of calls
<shka>
kakuhen: nothing is wrong with tracing
<shka>
it is nice and useful feature when you don't need debugger
<flip214>
lsip123_win10: you could also look at a stacktrace to find out how deep it's called
notzmv has quit [Ping timeout: 256 seconds]
<Viking667>
pjb: ah, okay. (re: if you don't put the ccl directory (with sources, etc) ...) so you'd recommend putting the sources there too?
<Viking667>
(as in, not JUST the image and kernel)?
jimka has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
shka has quit [Ping timeout: 268 seconds]
taiju has quit [Ping timeout: 272 seconds]
lad has joined #commonlisp
selwyn_ has joined #commonlisp
<lsip123_win10>
flip214: thanks for the suggestion
selwyn has quit [Ping timeout: 268 seconds]
<pjb>
Viking667: you can use ccl without the sources (just [wdl]x{86,ppc,arm}cl{32,64}{,.image}) But it's nice to be able to M-. and jump to the sources of ccl.
<pjb>
Viking667: also, I guess you'd also have to package the .app when you are on macOS for (require :cocoa), etc.
<pjb>
Viking667: I just keep the whole ccl directory and have the ccl script reference it. Usually /usr/local/src/ccl (but I also have alternatives such as /usr/local/src/ccl-git and old versions such as /usr/local/src/ccl-1.11) with /usr/local/bin/ccl /usr/local/bin/ccl-1.11 etc.
<pjb>
Viking667: sometimes you find bugs, so when you have the sources, you can easily correct them and generate a new image without the bug ;-)
<pjb>
Viking667: note: it's open since April, but still not integrated in ccl git. So if you encounter this bug, you better have a local patch!
<pjb>
(and there are older bugs with patches in issues…)
jimka has quit [Ping timeout: 272 seconds]
<Viking667>
mmm. I downloaded CCL today, so I think that one (at least) has been patched.
<Viking667>
nope.
<kakuhen>
i'm not sure who has commit access to the ccl git (besides rme himself), but i think there should be at least one more maintainer who isn't too busy to at least respond to issues within 3 months of their filing.
jimka has joined #commonlisp
<Viking667>
yeah. The weird thing is that the issue (at the bottom at least) is showing that someone committed a fix back on 1 June
<beach>
kakuhen: And how do you plan to find such a person/
<beach>
?
<kakuhen>
beach: the obvious way: you announce you're searching for such a person, or you ask people who have a well-recorded history of contributions and understanding of the project.
<kakuhen>
I'm not asking for a new maintainer to appear overnight.
<beach>
kakuhen: Do you have the qualifications for that screening process?
<kakuhen>
beach: I do not. Or else I would have done something about it.
MichaelRaskin has joined #commonlisp
<beach>
OK, so not only do we need a maintainer. We also need someone highly qualified who is in charge and who can search for another maintainer.
<Viking667>
ugh. Now I see where I went wrong, forgot to check informatigo's fork.
<kakuhen>
beach: what stops the primary maintainer of the project from doing this themselves within the span of a few years?
taiju has joined #commonlisp
<beach>
kakuhen: I don't know. I haven't talked to him lately. But typical reasons are day job, change of interest, etc.
<beach>
Also, it is not going to be easy to find a qualified maintainer with the right knowledge, experience, and availability.
<beach>
I think jackdaniel did the right thing for ECL. I don't think he had the right knowledge and experience when he started. But he was determined to learn. And nobody asked him as I recall; he just took over, so to speak.
<beach>
kakuhen: Nothing prevents you from doing the same.
<beach>
Now, if we could somehow cut down on the collective maintenance burden by factoring code so that it is then shared between different implementations, then the burden for each module would be smaller and more well defined.
<scymtym>
also, no maintainer at all can be better than an inexperienced maintainer who damages the codebase by "cleaning up", fixing problems only at the surface level, or removing things they don't understand
<kakuhen>
beach: Those typical reasons you gave are precisely why I think the time has been ripe to search for someone who may be willing to at least review an issue or PR and perhaps summarize information so that rme (or some other higher authority I'm not aware of) can decide to ultimately allow X change in the codebase. Sure, finding such a person is hard, but it's reasonable for people like myself to continue waiting anyway.
<beach>
scymtym: Good point. At least the person would have to feel some kind of responsibility, and also ask for advice.
random-nick has joined #commonlisp
<kakuhen>
Perhaps I can fork the project and add some patches, sure, but I'd expect myself to suffer the situation as scymtym described: I wouldn't probably understand the full consequences of my actions.
<beach>
That's when you ask for advice here, and as I recall, that's what jackdaniel has done.
dsk has joined #commonlisp
<beach>
kakuhen: I think what I am saying is that, if you don't do it yourself, then all that is happening right now is that you are asking one person (who apparently does not have enough time to take care of the maintenance) to do even more.
<beach>
jackdaniel: By the way, feel free to correct me about the statements regarding you and ECL.
<Viking667>
I think what I lack (though I have a passable amount of time) is experience in programming in general, though I've seen a whole boatload of languages from FORTRAN to smalltalk to C/C++/C# to java to lisp. Heck, I've even tinkered a little with scripting in bash.
<kakuhen>
beach: Yes. To some extent, I do find myself as a part of "the problem," so to speak, since nothing is really stopping me from forking CCL and patching whatever I want. And hopefully in the future I will know enough about Common Lisp and other relevant topics so that I can make a non-trivial change to CCL and thoroughly understand the consequences of my changes.
<kakuhen>
But that time is not now, unfortunately.
<Viking667>
so I wouldn't be a good maintainer. I'm getting my feet wet by going through Dolphin Smalltalk comments and picking out the mistakes and fixing those as I go. That's giving me a good look at the codebase while I'm at it
<Viking667>
but of course, Dolphin's not Lisp.
<kakuhen>
beach: And, as you pointed out, there are plenty of resources I can use to eventually get there. So expect a lot more dumb questions from me :)
<beach>
One thing that might help attract future maintainers is what is known as "preventive maintenance" is software engineering. The activity consists of code factoring, documentation, writing comments, writing tests, etc. that don't really change what the code is doing.
scymtym has quit [Ping timeout: 245 seconds]
<beach>
A potential maintainer is more likely to accept a clean code base than one that looks like a mess.
<beach>
So perhaps CCL has some low-hanging fruit in that department that doesn't require a whole lot of experience.
<phoe>
CCL has a lot of that
<beach>
I am not surprised.
<kakuhen>
Good idea, beach. I've always considered seeing the current test results on the latest release, but I've somehow never considered writing new tests myself, or seeing what is missing in terms of testing and documentation
selwyn has joined #commonlisp
selwyn_ has quit [Ping timeout: 245 seconds]
<beach>
Yes, write one test, one documentation string, or one extracted function per day. Submit your suggestion here before committing it.
<beach>
... or one comment, or update one function with better variable names.
<Viking667>
one of the chief problems that I've found (as you alluded to earlier) is that even though we can come up with fixes, getting someone to action a pull request—even if our code is 'clean'—is obviously the pain point of the CCL project at the moment.
<beach>
So I just opened a file nx0.lisp at random, and the first thing i see is a struct with slots named VDECLS, FDECLS, and MDECLS. How about changing those to function-declarations, variable-declarations, or whatever they are supposed to mean.
<beach>
That's a decent chunk of a "one thing per day" ativity.
<beach>
activity
<beach>
In the same file there are to-level comments with one or two semicolons, whereas the style recommended in the standard calls for three. Another single task.
<kakuhen>
Viking667: the PR i made for the missing feature reported by phoe about 6 months ago is a good example of that, but I'm confident that it will get merged into the codebase, either as-is or with whatever modification rme finds appropriate. I just have to wait. The situation is vastly different for those who are proposing non-trivial changes to CCL, however.
<Viking667>
*nod*
<Viking667>
Well, i'm off for now, I'm starting to run out of steam here (22:24 here)
<beach>
The function %nx-t is badly indented. One more thing to fix.
<beach>
This is just the first 25 lines of one file.
<kakuhen>
Viking667: heh, try 3:25 am
<kakuhen>
beach: You've made a good enough demonstration of your point.
<kakuhen>
I'll try finding some stuff myself tomorrow and attempt following a schedule for these little changes.
<beach>
And IF is used with no `else' branch. Ether replace with WHEN or supply the `else' branch as NIL (depending on the value is used).
<beach>
kakuhen: Thanks. To summarize, these improvements require very little experience. Only a sense of respect for conventions.
<beach>
(let ((pair ())) ....)
<beach>
That's also explicitly contrary to a Common Lisp HyperSpec dictionary page.
nirnam has quit [Ping timeout: 268 seconds]
Alfr has joined #commonlisp
<beach>
Using UNLESS in a position where the return value is meaningful.
<beach>
Unwarranted number of blank lines, decreasing the number of visible lines of code.
nirnam has joined #commonlisp
<beach>
I could go on all day with a single file, apparently.
<kakuhen>
Good to know. Hopefully that means I can find something to do daily.
<MichaelRaskin>
I would expect any kind of pushing upstream to be easier with good docstrings/extra tests/more readable names, than with piecemeal style fixes
<beach>
kakuhen: I think at this point I can promise you I could find enough stuff for a long time still.
<kakuhen>
You convinced me of this quite a while ago.
<beach>
Heh, OK.
<kakuhen>
With that said, I'm going to sleep. Good night, and thank you beach for the valuable input.
scymtym has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
<beach>
MichaelRaskin: So you are saying that we need to find a maintainer to improve docstrings, add more testes, improve names. But that's what we just decided is not easy at this point, and that piecemeal fixes would make it easier to find someone when these simpler fixes are being worked on.
<MichaelRaskin>
Piecemeal _style_ fixes reduce internal codebase consistency, though
anononon has joined #commonlisp
Viking667 has left #commonlisp [ERC (IRC client for Emacs 28.0.50)]
<MichaelRaskin>
Your VDECLS example is convincing, of course
<beach>
Well, when I suggested using three semicolons uniformly for top-level comments, I don't think there is any risk for that.
<beach>
But, yes, care must be taken not to make consistency worse.
<beach>
My initial impression is that consistency is not that great.
<beach>
And I can't see how an arbitrary number of blank lines is a consistent style feature. More like a mess.
frgo has quit [Remote host closed the connection]
<scymtym>
this is just a hypothetical example, but a tool for generating some kind of internal documentation could look for comments with a certain number of semicolons. assuming such a tool would not run as part of the default build process, breaking it could go unnoticed for a long time. not arguing against the suggested improvements, but illustrating how not knowing what you don't know can be tricky in complex code bases
frgo has joined #commonlisp
dsk has quit [Ping timeout: 272 seconds]
<beach>
I agree, of course. And that's the same argument that i use for people who use keywords for things like package names. Perhaps there is a tool that reads the source code, and if the package name is a keyword, it means something particular.
<beach>
So it must be determined that what looks like a mess, really is a mess, and nothing more sophisticated.
<beach>
Then, it would be very strange to create a tool that depends on some of the language conventions (even those explicitly mentioned in the standards document) being violated for the tool to work.
<scymtym>
sure, but code bases like ccl (or SBCL for that matter) seem like prime candidates for those things (which are undesirable, of course)
amb007 has quit [Read error: Connection reset by peer]
<beach>
Yes, that's true. I am reminded of the C macros of GCC for this idea.
amb007 has joined #commonlisp
Oddity has quit [Ping timeout: 240 seconds]
pve_ has joined #commonlisp
notzmv has joined #commonlisp
selwyn_ has joined #commonlisp
pve has quit [Ping timeout: 268 seconds]
<edgar-rft>
Don't under-estimate pseudo-sophistical ideas. I lived several years from telling the job center sophistically-sounding shit, and they paid me a lot of money for it. I initially hadn't expected that to become a successful business.
selwyn has quit [Ping timeout: 268 seconds]
Oddity has joined #commonlisp
* hayley
takes notes
nij- has joined #commonlisp
jimka has quit [Ping timeout: 256 seconds]
pranavats has left #commonlisp [#commonlisp]
amb007 has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
anononon has quit [Ping timeout: 248 seconds]
* rain3
taking notes too
<rain3>
edgar-rft: can you elaborate on that?
yitzi has joined #commonlisp
tyson2 has joined #commonlisp
fizbin has joined #commonlisp
<edgar-rft>
What's there to elaborate? As soon as they try to talk you into something you come up with an idea that sounds much better. Most of the people who work there are happy when you go and they have something to write down into their papers, no matter what. At the next date you tell them some completely different story. All you have to do is to make up new stories.
icepic1984[m] has quit [Ping timeout: 240 seconds]
Mrtn[m] has quit [Ping timeout: 276 seconds]
alphapapa[m] has quit [Ping timeout: 245 seconds]
dieggsy has quit [Ping timeout: 252 seconds]
Colleen has joined #commonlisp
andreyorst has joined #commonlisp
krjst has joined #commonlisp
mariari has joined #commonlisp
sterni has joined #commonlisp
remexre has joined #commonlisp
Jach has joined #commonlisp
taiju has joined #commonlisp
Vultyre has joined #commonlisp
wheelsucker has joined #commonlisp
fizbin has joined #commonlisp
Shinmera has joined #commonlisp
SAL9000 has joined #commonlisp
minion has joined #commonlisp
palter has joined #commonlisp
froggey has joined #commonlisp
thonkpod has joined #commonlisp
susam has joined #commonlisp
amk has joined #commonlisp
fpc has joined #commonlisp
dale has joined #commonlisp
ecraven has joined #commonlisp
taiju has quit [Remote host closed the connection]
luis` has joined #commonlisp
JooTvora[m] has joined #commonlisp
greyrat has joined #commonlisp
ski has joined #commonlisp
bldr has joined #commonlisp
dim has joined #commonlisp
mmk2410 has joined #commonlisp
specbot has joined #commonlisp
gwefnn has joined #commonlisp
happy-dude has joined #commonlisp
eta has joined #commonlisp
happy-dude has quit [Max SendQ exceeded]
waleee has quit [Ping timeout: 268 seconds]
frgo has joined #commonlisp
Kabouik has joined #commonlisp
scymtym has joined #commonlisp
retropikel has joined #commonlisp
Alfr has joined #commonlisp
dcx has joined #commonlisp
jgkamat has joined #commonlisp
dilated_dinosaur has joined #commonlisp
akater[m] has joined #commonlisp
energizer has joined #commonlisp
froggey-1 has joined #commonlisp
easye has joined #commonlisp
les has joined #commonlisp
spacebat1 has joined #commonlisp
zups has joined #commonlisp
jackdaniel has joined #commonlisp
gko has joined #commonlisp
taiju has joined #commonlisp
phantomics has joined #commonlisp
luis` has quit [Ping timeout: 252 seconds]
JooTvora[m] has quit [Ping timeout: 252 seconds]
akater[m] has quit [Ping timeout: 272 seconds]
katco has quit [Ping timeout: 268 seconds]
Gnuxie has quit [Ping timeout: 276 seconds]
hayley has quit [Ping timeout: 276 seconds]
amb007 has quit [Write error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
jimka has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
icepic1984[m] has joined #commonlisp
fizbin_ has joined #commonlisp
etimmons has joined #commonlisp
fizbin has quit [Ping timeout: 256 seconds]
ggoes_ is now known as ggoes
ggoes has joined #commonlisp
ggoes has quit [Changing host]
akater[m] has joined #commonlisp
JooTvora[m] has joined #commonlisp
hayley has joined #commonlisp
hayley has joined #commonlisp
hayley has quit [Changing host]
pranavats has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
katco has joined #commonlisp
Bike has joined #commonlisp
Mrtn[m] has joined #commonlisp
alphapapa[m] has joined #commonlisp
tyson2 has joined #commonlisp
Gnuxie has joined #commonlisp
dieggsy has joined #commonlisp
hafat has joined #commonlisp
luis` has joined #commonlisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
hafat has quit [Quit: Leaving]
fizbin_ has quit [Ping timeout: 245 seconds]
Inline has joined #commonlisp
<jackdaniel>
oh, I'm late to the party. :)
happy-dude has joined #commonlisp
<jackdaniel>
beach: basically correct. I don't consider my common lisp expierenced on par with other major implementations maintainers
<jackdaniel>
(and yes, asking here allowed me to avoid numerous pitfalls)
sander has quit [Remote host closed the connection]
lotuseater has joined #commonlisp
sander has joined #commonlisp
<beach>
Thanks for confirming.
tyson2 has quit [Remote host closed the connection]
<beach>
Taking on something like that is a great way of learning.
derelict has joined #commonlisp
Josh_2 has joined #commonlisp
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
dlowe has joined #commonlisp
copec has joined #commonlisp
Cymew has quit [Ping timeout: 268 seconds]
<mfiano>
Anyone know of a function that groups a sequence into chunks of length N? Like: (foo #(1 2 3 4 5 6) 3) ;=> #((1 2 3) (4 5 6)). Behavior when sequence isn't evenly divisible doesn't matter. Inner sequence type also doesn't matter.
<mariari>
group-by, I know the let over lambda book defines it and it's in the quicklisp package
<mfiano>
I see serapeum has #'batches, but I'd ideally not like to pull in 35 transitive deps for one use, and probably is too general anyway.
<mfiano>
Ah I might have it in my utility library if it's in LoL
<mariari>
yeah I tend to have a version in my own standard library for code which wants to play with ideas fast
<mfiano>
Thanks
rgherdt has quit [Ping timeout: 258 seconds]
d4ryus2 is now known as d4ryus
<mfiano>
Ah it's #'group, and it's specific to lists
<mfiano>
bummer
<mfiano>
Guess I'll write my own
<mariari>
you could generalize it easily enough, but yeah
<hexology->
is the name `:module` in asdf meant to signify something other than "a directory on the filesystem"? i'm curious about the choice of calling it `:module` as opposed to `:directory`
hexology- is now known as hexology
ec has joined #commonlisp
<mfiano>
hexology: Yes, it takes a pathname designator
<mfiano>
Not that the asd itself is the root module
<mfiano>
Note*
<mfiano>
Technically a module is just a collection of components
<hexology>
i see
<mfiano>
A module of file components can be thought of as a directory
<mfiano>
Note that you don't need modules to represent directories
<hexology>
so what does the pathname designator signify then? is i a "prefix" for all components in the module?
<hexology>
is it*
<mfiano>
A file component can have a relative path containing the directory
<mfiano>
The difference is minor, and most of the differences are due to how asdf detects changes for recompiling the system
<jcowan>
beach: Note that Kyoto CL (which is an ancestor of both ECL and GCL) was written by people isolated from the CL community as it was at the time. At least some style violations may descend from then.
<mfiano>
When a file's timestamp is modified, the next time that system is loaded, that file and files thereafter in the same module will be recompiled, assuming a serial load order
<mfiano>
hexology: (:module "foo" :components ((:file "bar))) is the similar to (:file "foo/bar")
jeosol has joined #commonlisp
<hexology>
i see, that helps clarify. is this documented somewhere?
<mfiano>
Except for change detection and some other things you may want to do that are only possible at the module level
<mfiano>
The asd system itself is the toplevel module by the way. You can think of DEFSYSTEM as being :MODULE
<hexology>
that makes sense now that you've explained it
<beach>
jcowan: I see. But the implementation we were talking about was CCL.
<jcowan>
Oh, my bad
<mfiano>
hexology: I believe it's all in the manual. That's how I learned years ago anyway
<hexology>
i see that several guides suggest putting source under "src/", and declaring src/ as a module. is that still considered best practice?
<hexology>
i did a search for "component type", "module", etc. saw a bunch of "what" but not "why", although there might be another manual (i was searching in the reference manual)
<mfiano>
hexology: It depends really. I usually do that except make the root module's :pathname point to "src" instead of putting everything in another root module
<mfiano>
note line 15. That is as if the root files were in a module called "src". But since the asd itself is the root module, you can just point the pathname it starts at
<hexology>
ah, and you use a dotted name for the test system
CrashTestDummy2 has quit [Ping timeout: 272 seconds]
Guest5143 has joined #commonlisp
notzmv has quit [Ping timeout: 248 seconds]
ec has quit [Ping timeout: 244 seconds]
waleee has joined #commonlisp
ec has joined #commonlisp
yitzi has quit [Quit: Leaving]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
Guest12 has joined #commonlisp
<santiagopim>
Hi! Any application that uses log4cl to show some log to the user ? I'd like to add some feedback to my users and need example code.
lisp123 has joined #commonlisp
d_run has quit [Ping timeout: 240 seconds]
IUSR has quit [Ping timeout: 240 seconds]
jmercouris has quit [Ping timeout: 240 seconds]
iisi has quit [Ping timeout: 258 seconds]
yitzi has joined #commonlisp
<Josh_2>
When I want output to a stream other than whatever the log4cl uses I just write a new format and capture the output through lexical binding instead
lad has quit [Ping timeout: 248 seconds]
<santiagopim>
Thanks. I'm trying to use the log4cl hierarchy to show different feedback levels on demand.
<santiagopim>
May be too complicated ... Don't know.
lisp123 has quit [Remote host closed the connection]
ec has quit [Ping timeout: 244 seconds]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 248 seconds]
karlosz has quit [Ping timeout: 258 seconds]
ec has joined #commonlisp
yitzi has quit [Quit: Leaving]
nirnam has quit [Remote host closed the connection]
dlowe has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 248 seconds]
loke has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<lisp123>
If a local variable exists with the same name as a global variable, a
<lisp123>
lexical closure will typically refer to the local variable.
<lisp123>
I got the above note somewhere
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
<lisp123>
Is that true?
rain3 has quit [Ping timeout: 258 seconds]
<Guest12>
lexical scoping rules apply, so nearest binding wins
<lisp123>
defvar will define a special variable. This declaration is global and also has effect on let bindings. That's the reason that by convention these variables are written as *foo*. If you have ever defined x with defvar, it is declared special and there is no way to declare it lexical later.
<lisp123>
Guest12: That's what I thought. I guess what is so 'special' about special then?
<shka>
lisp123: special declaration
<lisp123>
(I used to know the answer but its been a while)
<Bike>
whether a variable is treated as dynamic (special) or lexical is a lexical property, confusingly enough. you can change it in a lexical scope with a SPECIAL declaration. global special proclamations (as defvar does) are extra special in that they make other bindings special too
<shka>
"special" variable binds value for everything under the stack
yitzi has joined #commonlisp
<shka>
special refers to the scope, not to the binding form
<shka>
that's how i think about it
<lisp123>
Bike & shka: so if we change the value of a special variable, does it affect the value of the global variable?
<Alfr>
lisp123, maybe.
<lisp123>
(if done within a let which binds to the same symbol)
<Bike>
in that case no.
<shka>
local vs special is false dichotomy
<Bike>
when a variable is special, operations on it (both reads and writes) use the closest enclosing binding.
<Bike>
if you really want to specifically mess with the global value you can use symbol-value.
<jcowan>
THe explanations in the CLtL chapter "Scope and Extent" are extremely helpful, I think
<lisp123>
jcowan: yeah they are, I should re-read them
<lisp123>
I guess I have to read the stuff carefully again, as there isn't a simple rule to apply (have to factor in both scope & extent)
<lisp123>
Thanks Bike & shka
<shka>
what is not false dichotomy is perhaps lexical scope vs the special scope
<shka>
it is all about the scope
<jcowan>
CL isn't entirely orthogonal, though; short of symbol-macro tricks, all global variables are dynamic. In ISLisp, this isn't true: there are separate namespaces, define forms, and let forms for dynamic and lexical variables.
<jcowan>
defglobal/defdynamic, let/dynamic-let.
<Guest12>
The lexical scope works like you might expect in any langauge, it's the dynamic extent and associated binding stack that is new to non-lispers.
iisi has quit [Ping timeout: 258 seconds]
iisi has joined #commonlisp
<Guest12>
If you run this bit, *x* comes up 2 because of this principle.
<Guest12>
(defvar *x* 1)
<Guest12>
(defun y () (format t "*x* = ~s~%" *x*))
<Guest12>
(let ((*x* 2))
<Guest12>
\
<Guest12>
(defvar *x* 1)
<Guest12>
(defun y () (format t "*x* = ~s~%" *x*))
<Guest12>
(let ((*x* 2))
<Guest12>
(y)
<Guest12>
*x*)
<Josh_2>
bruh
<Guest12>
Dang, can't get the emojis out.
<Guest12>
New to this.
<Josh_2>
can you use a paste if you are going to multiline
IUSR has quit [Ping timeout: 248 seconds]
<Guest12>
Yeah, apologies, haven't used this web client before
<Josh_2>
Np
tfeb has joined #commonlisp
ec has quit [Ping timeout: 244 seconds]
<Alfr>
Guest12, but your global variable *x* still have 1 for its value afterward.
<Guest12>
Yes, but that's because the '2' binding is no longer active.
<Alfr>
Yes.
<Guest12>
I don't know of a good tutorial for this, I'm out of practice. I'm sure there is one, but it isn't the hyperspec ;-)
<Guest12>
Thought there is quite a bit of useful content on the subject in the hyperspec, it's hard to find.
<Alfr>
Guest12, maybe clhs 3.1.1 ?
ec has joined #commonlisp
IUSR has joined #commonlisp
tfeb has quit [Quit: died]
tfeb has joined #commonlisp
hafat has joined #commonlisp
tfeb has quit [Client Quit]
dsk has joined #commonlisp
Guest12 has quit [Ping timeout: 246 seconds]
kakuhen has joined #commonlisp
Guest12 has joined #commonlisp
yitzi has quit [Quit: Leaving]
mrcom has quit [Quit: Konversation terminated!]
akoana has joined #commonlisp
lad has joined #commonlisp
ec has quit [Ping timeout: 244 seconds]
ec has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Guest12 has quit [Quit: Client closed]
tyson2 has joined #commonlisp
amb007 has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
<mfiano>
jcowan: There is a (semi-; 3 popular implementations) portability library for true global variables.
<jcowan>
Yes, that depends on symbol-macro, right?
<mfiano>
No
<mfiano>
Implementation-specific features
<mfiano>
Like threads etc
<mfiano>
I mean, just as threads are not standard
<mfiano>
On the implementations lacking support it will fall back to what you speak of, though.
<mfiano>
But I would say SBCL, CCL, and LispWorks is a decent start for implementation support.
<mfiano>
Maybe more have it these daya, as the library is fairly old, in which case the library needs to be updated to wrap them too.
<mfiano>
jackdaniel should know if ECL supports such a thing.
amb007 has quit [Read error: Connection reset by peer]
<mfiano>
But, I do use global-vars in my own codes fairly often when I need global state without such a runtime overhead as dynavars.
amb007 has joined #commonlisp
<mfiano>
Night all!
<Josh_2>
G'night
ec has quit [Ping timeout: 244 seconds]
ec has joined #commonlisp
scymtym has quit [Ping timeout: 272 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123_ has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
lisp123__ has joined #commonlisp
nirnam has joined #commonlisp
scymtym has joined #commonlisp
<jasom>
Does anyone else wince in pain when they see a commit that adds code that uses "ignore-errors" /
<phoe>
(ignore-errors (say "No, not at all"))
lisp123_ has quit [Read error: Connection reset by peer]
<_death>
it doesn't actually ignore the errors, and can return them as the secondary value, so may be ok
pve has joined #commonlisp
<kakuhen>
jasom: i havent seen that yet, but i do find extraneous DECLAREs amusing
<kakuhen>
ive ran into some lisp code where a function takes in arguments foo, bar, baz, yet they (declare (ignorable foo bar baz))
<kakuhen>
presumably the original writer of the function was testing some things and forgot to remove the declare
<phoe>
oh right, it signals a file-error if it fails to delete the file
ec has quit [Ping timeout: 244 seconds]
ahc has joined #commonlisp
shka has quit [Ping timeout: 258 seconds]
ec has joined #commonlisp
lisp123__ has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
nij- has joined #commonlisp
selwyn_ has quit [Read error: Connection reset by peer]
lisp123 has quit [Read error: Connection reset by peer]
<phoe>
that's why uiop:delete-file-if-exists is a thing
<jasom>
Right, I would be okay if it silently consumed a file-error, but this could hide bugs like the stream not actually being a stream
<phoe>
yes
<jasom>
That's my bigger issue with ignore-errors is that it only works if you only get the errors you expect, and if you know which errors you expect, you can handler-case those away
nij- has left #commonlisp [#commonlisp]
<_death>
sigh.. seems cl-sqlite doesn't call sqlite3_close() when sqlite3_open()'s error code is not :ok
Guest5143 has quit [Quit: Client closed]
nirnam has quit [Remote host closed the connection]
<lotuseater>
oh does it need an UNWIND-PROTECT ? ^^
<_death>
it needs code to do that before signaling an error
<lotuseater>
:)
nij- has joined #commonlisp
lad has quit [Ping timeout: 248 seconds]
<Alfr>
phoe, I always thought that is just a remedy for the implementation dependence of deleting a non-existing file.
byleth has joined #commonlisp
ec has quit [Ping timeout: 244 seconds]
lisp123 has joined #commonlisp
nirnam has joined #commonlisp
<pjb>
phoe: why does a name such as delete-file-if-exists starts the red alert in my mind? (uiop:delete-file-if-exists "/etc/passwd") -> nil which is wrong, you want a file-error in that case!
<pjb>
phoe: note: (progn (uiop:delete-file-if-exists "/etc/passwd") (probe-file "/etc/passwd")) #| --> #P"/private/etc/passwd" |# and no other process created it in between!
ec has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
luna-is-here has quit [Remote host closed the connection]
Inline_ has joined #commonlisp
Inline has quit [Ping timeout: 258 seconds]
edgar-rft has quit [Ping timeout: 276 seconds]
luna-is-here has joined #commonlisp
scymtym has quit [Ping timeout: 258 seconds]
edgar-rft has joined #commonlisp
scymtym has joined #commonlisp
karlosz has joined #commonlisp
gaqwas has quit [Ping timeout: 258 seconds]
rgherdt has joined #commonlisp
pve has quit [Quit: leaving]
lisp123 has quit [Ping timeout: 248 seconds]
rgherdt has quit [Ping timeout: 272 seconds]
raeda has joined #commonlisp
nij- has quit [Remote host closed the connection]
nij- has joined #commonlisp
byleth has quit [Ping timeout: 248 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
ec has quit [Ping timeout: 244 seconds]
Inline_ has quit [Ping timeout: 272 seconds]
rain3 has joined #commonlisp
ec has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 268 seconds]
gaqwas has joined #commonlisp
karlosz has quit [Quit: karlosz]
khrbt_ has joined #commonlisp
khrbt_ is now known as khrbt
tyson2 has joined #commonlisp
khrbt is now known as khrbt_
ec has quit [Ping timeout: 244 seconds]
fizbin has joined #commonlisp
gaqwas has quit [Ping timeout: 258 seconds]
ec has joined #commonlisp
PinealGl1ndOptic has quit [Quit: leaving]
derelict has quit [Quit: WeeChat 3.2]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]