dbotton has quit [Quit: This computer has gone to sleep]
tinhatcat has quit [Quit: Leaving]
Nilby has joined #lisp
tinhatcat has joined #lisp
martinjungblut has left #lisp [#lisp]
abhixec has quit [Ping timeout: 260 seconds]
dbotton has joined #lisp
tinhatcat has quit [Client Quit]
dbotton has quit [Quit: Leaving]
Josh_2 has quit [Remote host closed the connection]
prxq_ has joined #lisp
tinhatcat_ has joined #lisp
tinhatcat_ has quit [Client Quit]
jpli has joined #lisp
prxq has quit [Ping timeout: 264 seconds]
slyrus has joined #lisp
<beach>
Good morning everyone!
<asarch>
Guten Tag!
<asarch>
Wie geht's?
Alfr has joined #lisp
<kamen>
Morning...
<asarch>
:-)
<beach>
Me? Doing great. I am about to use Bike's implementation of Kildall's algorithm to compute "estimated distance of use" for each lexical variable in intermediate code, in order to then implement register allocation.
<beach>
kamen: Are you new here? I don't recognize your nick.
cchristiansen has quit [Read error: No route to host]
vutral_ has joined #lisp
bjorkintosh has joined #lisp
cchristiansen has joined #lisp
thmprover has quit [Quit: This parting was well made]
matryoshka has quit [Read error: Connection reset by peer]
matryoshka has joined #lisp
kaiwulf has quit [Ping timeout: 260 seconds]
sm2n has joined #lisp
pankajsg has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
sm2n has quit [Read error: Connection reset by peer]
sm2n has joined #lisp
NULLean` has quit [Remote host closed the connection]
aggin has joined #lisp
iskander- has joined #lisp
notzmv has joined #lisp
iskander has quit [Ping timeout: 240 seconds]
<kamen>
beach: Yup, I'm new. Been hanging around some irc channels (emacs, etc.), but hadn't dared to venture in #lisp yet. No idea why.
ex_nihilo has quit [Ping timeout: 240 seconds]
<pyc>
Nilby: yesterday, you said, "Everything that still works, works because they don't depend on external conditions. But for most useful things, the external conditions have changed enough that they don't run."
orivej has quit [Ping timeout: 260 seconds]
<pyc>
Nilby: What does "external conditions" mean?
<pyc>
kamen: how did you finally decide to join #lisp? for me the journey was opposite. I first decided to learn Lisp and that led me to Emacs.
zacts has quit [Quit: leaving]
aartaka has joined #lisp
<Nilby>
pyc: Things like databases, web servers, some O/S things like file locations, and I was running on Solaris OS on 32 bit sparc hardware at the time.
<Nilby>
But some things I still use to this day.
<pyc>
Nilby: okay. I am still learning CL so not familiar with the term "external condition". Does "external condition" mean external package?
<Nilby>
pyc: No. I just meant things like the O/S, network, and external programs, like database and web servers,
<pyc>
Nilby: what does "condition" mean in that term?
<Nilby>
pyc: The packages I used, like e.g. CLSQL still work the same.
<Nilby>
Not Lisp conditions, just the software external to Lisp.
<pyc>
Nilby: oh!
<pyc>
Nilby: so if I understood you right, things like CLSQL still work the same. But things like O/S, network, etc. that you depended on in Solaris OS days, don't work the same and you had to rewrite some of that code?
aggin has quit [Quit: leaving]
aggin has joined #lisp
toorevitimirp has joined #lisp
charles` has joined #lisp
hjudt has joined #lisp
<Nilby>
Yes. Like for example, migrating from an Oracle database to Postgresql, and from Apache web server to hunchentoot or nginx
<pyc>
Nilby: thanks
<beach>
kamen: Great! Welcome!
aggin has quit [Client Quit]
aggin has joined #lisp
<beach>
kamen: What made you finally decide to join?
<pyc>
Nilby: Can one create a web-based application in Common Lisp directly using CLHS functions and Nginx or do you need to use Hunchentoot for it?
cchristiansen has quit [Remote host closed the connection]
<Nilby>
pyc: In general, the CL code I've written is more portable, than any other language I've ever used.
<pyc>
Nilby: that is great to know. what other languages are in your mind when you say that CL code is more portable than them? Python, Java? or something else?
<Nilby>
pyc: Back then was before hunchentoot existed so I just used sockets code to talk to mod_lisp in an apache server. If the whole system was never touched, it could still run today, but people like to upgrade things
<pyc>
Nilby: how about now? can I write a Common Lisp web application without Hunchentoot and serve it over the Internet via Nginx or something like Hunchentoot is necessary?
aggin has quit [Client Quit]
aggin has joined #lisp
aggin has quit [Client Quit]
aggin has joined #lisp
<Nilby>
Yes. I mean you can make a HTTP 1 server from a few lines of CL code using implementation specific (or OS specific) socket code, but things like hunchentoot make things easier.
<pyc>
okay, so I will learn hunchentoot once I become more comfortable with CL
<pyc>
ah! looks like I have done a hello, world with Hunchentoot already. the Emacs4CL script I used to set up my Emacs introduced me to Hunchentoot in its docs. it had a Hunchentoot example to demo quicklisp: https://github.com/susam/emacs4cl#use-quicklisp
<pyc>
Nilby: can you take a look at my other question above: what other languages are in your mind when you say that CL code is more portable than them?
<pyc>
Nilby: just curious to know CL is more portable in comparison to what else?
<Nilby>
The application I'm thinking of was in C++ before I converted it to Lisp. CLSQL gave me the cool ability to write mostly DB independent SQL, as well as immediately work on different DBs, but more importantly I could write SQL, HTML, and application logic using the same Lisp syntax.
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
<Nilby>
C++ has more libraries and features now, but back then it was impossible.
__jrjsmrtn__ has joined #lisp
<kamen>
beach: Oh, nothing special. Since I had resurrected ERC, I thought I might as well hang around, lurk and read/listen to lispers. Also, I've stopped dabbling in CL and started taking it a bit seriously, so, as "ongoing education", it's a good idea to be here.
<beach>
Sounds good. Don't hesitate to ask questions.
<aggin>
is there a :folder like there is a :file in asdf:defsystem :components ?
<aggin>
I want asdf to take files from a certain directory
<aggin>
without defining a new module
waleee-cl has quit [Quit: Connection closed for inactivity]
charles` has quit [Ping timeout: 264 seconds]
sm2n has quit [Read error: Connection reset by peer]
<pyc>
what does the term "sharplisper" mean? Found it in the channel logs.
<beach>
It's a GitHub repository.
<beach>
We gather abandoned code there and try to maintain it a bit.
sm2n has joined #lisp
<beach>
I didn't create it, but I am convinced it's a pun, like #lisp-ers.
<jackdaniel>
a sharp lisper is a lisper who is sharp
<Nilby>
edgey sharplispers keeping those old blades from rusting :)
<beach>
jackdaniel: As opposed to "flat"?
<jackdaniel>
beach: I thought of "dull" or "blunt"
<beach>
Just checking.
<edgar-rft>
let's write lisp in a minor
kktt0071 has joined #lisp
<jackdaniel>
(but a music reference is a nice touch too)
<jackdaniel>
that said, I'm to make an owl from a play dough, see you \o
landakram has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
varjagg has joined #lisp
<pyc>
what am I doing wrong in this statement: (uiop:with-current-directory "/tmp/" (uiop:getcwd)). I get: Error while parsing arguments to DEFMACRO UIOP/FILESYSTEM:WITH-CURRENT-DIRECTORY:
aartaka_d has joined #lisp
shka_ has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
aartaka has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
<Nilby>
pyc: When a macro has an arg in parens, it has to be in parens when you use it. So in your case it's (with-current-directory ("/tmp/") ...)
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<beach>
pyc: Common Lisp has "statements" only inside TAGBODY. In general, an expression meant to be evaluated is called a "form".
<pyc>
thanks Nilby beach
narimiran has joined #lisp
kktt0071 has left #lisp ["User left"]
aindilis has quit [Ping timeout: 240 seconds]
ldbeth has joined #lisp
rumbler31 has joined #lisp
<ldbeth>
good afternoon
holycow has quit [Quit: Lost terminal]
<beach>
Hello ldbeth.
<ldbeth>
just come up to head, but are there any style guides mention when to use `&aux'?
rumbler31 has quit [Ping timeout: 240 seconds]
abhixec has quit [Quit: leaving]
abhixec has joined #lisp
<beach>
Most people say "never", but I found a use for it, as described in my paper on method combinations.
<ldbeth>
got it
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<jackdaniel>
it is useful when you want to introduce a binding that wraps whole body (i.e you want to rebind an argument)
<jackdaniel>
there is only so many strings you can put in a string
ewd has joined #lisp
<beach>
That's beautiful.
<ldbeth>
ah, it's some kind of coercesion
<beach>
And that's precisely the use in the paper I mentioned. It needs to wrap an entire body of externally-supplied code.
varjagg has quit [Ping timeout: 240 seconds]
<jackdaniel>
ah, happy coincidence
<Nilby>
please LET &aux die
<beach>
Nilby: Then I couldn't implement my technique for method combinations.
<Nilby>
I have total faith that you could
wanko has quit [Ping timeout: 256 seconds]
<beach>
I don't think it has any great use in a function that is entirely written by the programmer. But in this case, I needed it because the body of the code could be arbitrary, and I had to wrap it as jackdaniel said.
<Nilby>
someday I'll go back in time and get rid of &aux and nobody will miss it
Kingsy has quit [Changing host]
Kingsy has joined #lisp
<beach>
Nilby: If so, I challenge you to come up with an alternative solution to the problem in that paper.
zaquest has quit [Quit: Leaving]
<beach>
Nilby: It could be your ELS submission this year: "Method combinations without &aux".
<Carkh>
aggin: maybe the :pathname key in a system definition does what you want ?
<aggin>
ok thanks
zaquest has joined #lisp
lottaquestions_ has quit [Remote host closed the connection]
lottaquestions_ has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
ldbeth has quit [Quit: ERC (IRC client for Emacs 27.1)]
aggin has quit [Quit: WeeChat 3.0.1]
contrapunctus has joined #lisp
rgherdt has joined #lisp
random-nick has joined #lisp
landakram has quit [Ping timeout: 240 seconds]
ex_nihilo has joined #lisp
asarch has quit [Quit: Leaving]
ukari has quit [Remote host closed the connection]
surabax has joined #lisp
ukari has joined #lisp
hjudt has quit [Remote host closed the connection]
supercoven has joined #lisp
matryoshka has quit [Ping timeout: 272 seconds]
jeosol has quit [Quit: Connection closed]
ljavorsk has joined #lisp
jayspeer has joined #lisp
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
slyrus has joined #lisp
nicktick has quit [Ping timeout: 276 seconds]
aartaka has joined #lisp
slyrus has quit [Ping timeout: 276 seconds]
aartaka_d has quit [Ping timeout: 240 seconds]
<scymtym>
beach: another use of &AUX is computing the value of a structure slot depending on constructor arguments: (defstruct (foo (:constructor make-foo (bar &aux (baz (1+ bar))))) bar baz)
<beach>
Interesting. I didn't catch that one because I never think about using structures.
heisig has joined #lisp
<dim>
I must admit I like using structures a lot, and that might be because when using CCL it's possible to change their definitions online, much like classes
<beach>
But then your code is implementation specific.
<Carkh>
isn't there efficiency considerations to take into account ?
vutral_ has quit [Quit: Connection closed for inactivity]
<Carkh>
like generic accessors
<Carkh>
vs static
<pyc>
Is it true that 'loop' is discouraged and something like 'mapcar' is encouraged to adhere to more functional programming style?
gj has joined #lisp
<beach>
Carkh: It depends on the generic dispatch algorithm that your implementation is using. But, yes, with current implementations, it is usually agreed that structures are faster than standard classes/objects.
<beach>
pyc: No.
<Carkh>
beach : thanks
<pyc>
beach: thanks
<gj>
hello!
<beach>
Hello gj.
<gj>
I am here again because I am still a little bit confused about using packages in a lisp program.
amb007 has joined #lisp
<beach>
pyc: Common Lisp is a multi-paradigm language. You will find the functional style mostly in macro expanders. Of course, someone who wants to program in Common Lisp using a functional style may want to avoid imperative constructs.
catt has joined #lisp
<beach>
Carkh: Now, if current implementations used my algorithm for generic dispatch and my technique for call-site optimization, the conclusions may be different. :)
<gj>
Things like asdf and quicklisp seem to only work in a REPL? how does it work if I want to do things outside of a REPL?
<gj>
sorry if there is a really obvious answer to this.
jonatack has joined #lisp
<beach>
gj: You use those tools to build your program. And you would not usually build your program at run time.
<Carkh>
beach : i was under the impression they were doing call site optimization ? or was it java ?
<flip214>
> The Python version had less code that ran faster
attila_lendvai has joined #lisp
<beach>
I need to put the first one on the queue. I can't figure out how Python would be faster. Maybe they were using CLISP initially?
<flip214>
hmmm, has that ever been the case?
<jackdaniel>
maybe the lisp code was badly written code?
<jackdaniel>
I mean - experienced python programmer can write faster code than inexperienced lisp programmer who takes into the heart, that "everything is a list"
<kamen>
Ah, the reddit from-lisp-to-python case. What a shitstorm that ended up as.
rumbler31 has quit [Ping timeout: 240 seconds]
<flip214>
jackdaniel: the article says "knows about lisp", though
<flip214>
well, never mind.
<jackdaniel>
or: overly ambitious lisp programmer tries to do the right thing, while not exactly the right things gives faster code
<pyc>
flip214: which article says, "knows about lisp"?
<flip214>
pyc: the rewritingreddit one. > the others knew Lisp
lowryder has quit [Ping timeout: 245 seconds]
lowryder has joined #lisp
APic has joined #lisp
acolarh_ has quit [Quit: WeeChat 1.9.1]
acolarh has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
kam1 has joined #lisp
skapata has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
vegansbane6963 has joined #lisp
davros has joined #lisp
ldbeth has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
APic has quit [Ping timeout: 245 seconds]
APic has joined #lisp
niac has quit [Ping timeout: 264 seconds]
retropikzel has quit [Quit: Leaving]
ldbeth` has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
luni has joined #lisp
kamen has quit [Remote host closed the connection]
ldbeth`` has joined #lisp
ldbeth` has quit [Ping timeout: 245 seconds]
phanstig has quit [Quit: Leaving]
sm2n has joined #lisp
kevingal has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
<Carkh>
if i set the fill-pointer of a vector to a lower value, should i first fill the upper array cells with nil in order to help the garbage collector ?
<beach>
You might want to do that, yes.
<Carkh>
sounds like this might be implementation dependant
ldbeth``` has joined #lisp
<beach>
Because there are operations that ignore the fill pointer.
<beach>
No, I don't think so.
<Carkh>
allright makes sense, thanks
<beach>
AREF ignores the fill pointer, so the objects beyond the fill pointer can't be reclaimed.
<Carkh>
i didn't know that, i was expecting an error
<Carkh>
it's slower, but the trickj is to flatten the data structur
<Carkh>
e
surabax has quit [Ping timeout: 240 seconds]
<Carkh>
but yeah, there's a reason i'm back to CL
<beach>
Sure, if we don't care about performance, anything can be done functionally.
kam1 has quit [Ping timeout: 276 seconds]
<Carkh>
though CL is not always that friendly towards non-consing imperative stuff... sometimes feels like fighting it
<beach>
Oh?
<beach>
Ah, yes, sorry. Misread. Sure.
<beach>
The, consing is not a problem in general. Only in Common Lisp implementations with bad garbage collectors.
<Carkh>
i'd say yes and no
<beach>
That remark kind of requires some elaboration.
<Carkh>
wasn't it ITA or whatever is the name of this trip calculating application that had to keep its data in a C application ?
<beach>
Could be. Why was that?
<Carkh>
ok so here it is : i'm trying to make a game, 60fps not required, and i'm glad it isn't because i don't think i could maintain it with CL
retropikzel has joined #lisp
<Carkh>
sure a small toy thing will work nicely
<Carkh>
but even for the small thing you have to be VERY carefull about consing
<beach>
Why is that?
<Carkh>
frame drops
<beach>
Because of the GC?
ldbeth``` has quit [Ping timeout: 264 seconds]
<Carkh>
that's my guess anyways
<beach>
That just confirms what I said. It is a problem only with Common Lisp implementations with bad garbage collectors.
<Carkh>
sbcl has a bad garbage collector ?
<beach>
Absolutely.
<Carkh>
which one is good ?
<beach>
SBCL started life many decades ago, and we didn't know then what we do now.
<Carkh>
i mean, i'm pretty sure SBCL has good throughput
<Carkh>
but this isn't especially suited to games i guess
<beach>
Pretty much all Common Lisp implementation currently used, at least the free ones, started life a very long time ago, and nobody has implemented a good concurrent and parallel GC for them.
<beach>
Last time I looked, SBCL had a stop-the-world GC.
<Carkh>
will you dive into concurrent GC for SICL ?
<beach>
That's the plan, yes.
<Carkh>
wew dear i'm glad you're doing it rather than me =)
<beach>
It hasn't been tested, but the basic design is based on fairly recent research.
<Carkh>
guess i'll have to come back in about 10 years =)
<beach>
I totally hope it won't take us that long to get SICL going.
<beach>
The applications I had in mind for this design are "analysis, processing, and synthesis of sound"
<beach>
And sound is even more sensitive to pauses than video.
<Carkh>
yes that's soft realtime right thre
<beach>
Exactly.
<Carkh>
though with sound you can schedule stuff a bit in abvance depending on buffer size
retropikzel has quit [Remote host closed the connection]
<Carkh>
do you intend to treat windows as first class environment with SICL ?
slyrus has joined #lisp
<beach>
You have to make sure that the application responds adequately fast to the user pressing some key on the MIDI keyboard.
<beach>
"windows"?
<Carkh>
microsoft windows... I notice it's nothing but an afterthought for most implementations
<beach>
I have no time or energy for Microsoft products, and very little for Unix as well, so I think the answer is "no".
<beach>
But I am sure there will be someone else doing it.
<beach>
Just like someone will probably make SICL support CFFI or something like that.
<Carkh>
that's something i'll never understand, the users are on windows, most of them anyways
<beach>
I am a researcher. I don't care if I am the only user of SICL.
<Carkh>
no common lisp advocacy on your part then ?
<beach>
I gave up trying to convince people of just about anything many decades ago.
<beach>
I do my job and try to show good results. If people don't care, then that's their problem.
<Carkh>
that was a loaded question anyway
<Carkh>
i mean there are advantages to having a larger community
<Carkh>
maybe more hands to help you with SICL for instance
<beach>
Yes, but the kind of people that would be attracted by "advocacy" are not the kind of people I would like help from.
<jackdaniel>
beach succesfully attracted quite a few people without marketing deparatment :)
<beach>
There is already a handful of people doing real good work for me. That's enough.
<beach>
Carkh: What jackdaniel said.
<Carkh>
that's only an example, there is also more brains to come up with ideas
<jackdaniel>
another thing is that effort of managing low quality contributions sometimes is bigger than not accepting them
<jackdaniel>
(or persuading)
<beach>
I seem to come up with more ideas per time unit than I have time to implement. So the backlog is already considerable.
slyrus has quit [Ping timeout: 264 seconds]
<jackdaniel>
heck, even a consensus with knowledgeble people is hard in quantity of 2-3 devs!
<Carkh>
sur the newly "advocated" person is useless, but he/she might grow
<Carkh>
sure*
<Carkh>
community gardening =)
<jackdaniel>
might or might not, the free time you put in growing someone you don't know doesn't grow on trees
<jackdaniel>
well, I'm sure that there are positive examples, but there is some merit in not making a community bubble :)
<beach>
Carkh: It is part of my job to help people make progress, but I don't do it hoping that they will contribute to SICL.
<Carkh>
i shouldn't have mentioned SICL, it was just an example
<beach>
Carkh: For the past 40 years or so, I have "attracted" people by showing what I can do, without talking much about it, and certainly without trying to "market" it. I think I have a good track record of attracting people that have understood the point of what I do.
<Carkh>
so you're saying there's no value in advocacy
<jackdaniel>
I think that you extrapolate too much
<Carkh>
i disagree on that, but to each their own
<beach>
Almost. It is certainly not worth *my* time, but that can be because I am not very good at it.
<jackdaniel>
i.e fact that I'm not going to the cinema does not equal to saying that I don't see value in going to the cinema
<Carkh>
ok i understand
<beach>
Carkh: I also think it is risky. I frequently see people asking questions here in order to "sell" Common Lisp to their manager, but those people would have no clue whatsoever when they then are asked to handle problems with their proposed solutions.
<beach>
... and such a situation would be very bad for the image of Common Lisp indeed.
aggin has joined #lisp
<beach>
There are exceptions, of course. Like flip214, who knows what he is talking about.
<Carkh>
again thinking about clojure, rich hickey spent a lot of time doing advocacy, and this resulted in a vibrant community and some tools and solutions that are objectively the best for their purpose (that i know of)
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
<Carkh>
anyways back to work, thanks for the chat
<ldbeth>
I think I see "MIDI" in the conversation
<beach>
Carkh: Also, this is probably not a good time to push Common Lisp to a wider audience. Our development tools are not that great, and as you pointed out, the garbage collectors of existing implementations are not that great either. We are working on improving it though.
<ldbeth>
Is there any material I can reference for how to do "real time" signal processing in CL?
<jackdaniel>
n.b abcl relies on jvm gc, so it is rather good given how much effort has been put into that technology
<Carkh>
beach: i sure feels like there is more activity these days than 10 years ago
<beach>
jackdaniel: Good point.
<Carkh>
it*
<Carkh>
though it still firmly smells funny =)
<ldbeth>
to be more specific, I'd like to know how to keep video and sound in sync, but unfortunatly I have no experience in game programming etc
skapate has joined #lisp
matryoshka has joined #lisp
cage_ has joined #lisp
matryoshka has quit [Remote host closed the connection]
<Carkh>
i'm yet to tackle the sound issue, looks like there are a few libs to be found with borodust
narimiran has quit [Ping timeout: 245 seconds]
<Carkh>
calling into C libraries
Codaraxis_ has quit [Remote host closed the connection]
Lycurgus has joined #lisp
skapata has quit [Ping timeout: 272 seconds]
matryoshka has joined #lisp
<beach>
ldbeth: I know of no such material. Even with more traditional languages, the OS is going to get in your way a lot. I can't even get a real-time synthesizer program to give adequate response times on Linux. I am told I need to recompile the kernel for that.
<Carkh>
namely bodge-openal
<Carkh>
bodge-sndfile and its sndfile-blob
<Lycurgus>
yeah that's standard
<Lycurgus>
the normal linux kernel isn't real time
<Lycurgus>
the build is pretty straightforward though
<beach>
So why is it not real time by default?
<Lycurgus>
not the default use case?
<Carkh>
probably because there is a tension between throughput and realtimeness
<Lycurgus>
also it's pretty easy on most distros
<ldbeth>
Carkh: ah, so I accept that it is not easy to accomplish this with trivial programs.
<beach>
Lycurgus: What use case would be disadvantaged if it were real time by default?
<Lycurgus>
debian derived ones anyway
<Lycurgus>
all my hosts in this LAN for example and this one I'm typing on where I expect interactive resposivity
<beach>
I think I need a competent system administrator.
<Lycurgus>
also switching will be easy from grub
<beach>
I can't even get an adequate desktop environment without specific adaptations.
<Lycurgus>
but this host hasn't been rebooted in a couple months
<Lycurgus>
did have to restart X/vnc a few days ago loosing my desktop
<beach>
I think I could convince someone to be my system administrator, but I have no idea how that would work remotely.
<Lycurgus>
*responsivity
<Lycurgus>
i'd do it on retainer :)
<beach>
What does that mean?
<Lycurgus>
what does retainer mean?
<beach>
You mean you would get paid in advance?
<beach>
I could do that.
<beach>
But I still don't see how it solves the remote problem.
<Lycurgus>
k, juan@acm.org ; ( to get back on topic )
Codaraxis has joined #lisp
jayspeer has quit [Quit: ERC (IRC client for Emacs 27.1)]
<beach>
I guess I'll wait until I have replaced my desktop. It is time for that.
<beach>
My desktop computer I mean.
<Lycurgus>
remote isn't a reall issue these days; was gonna sey, dedicate a box to rt if it's important
<beach>
That's an idea.
orivej has joined #lisp
<Lycurgus>
in terms of defaultness order: server, desktop, rt and other specialty
<beach>
Thanks for the advice. When I have time, I'll give it some more thought. It is a very attractive idea.
<Lycurgus>
np
Sheilong has joined #lisp
ldbeth` has joined #lisp
ldbeth has quit [Ping timeout: 276 seconds]
aggin has quit [Quit: WeeChat 3.0.1]
ldbeth` has quit [Ping timeout: 245 seconds]
Lycurgus has quit [Quit: Exeunt]
slyrus has joined #lisp
caret has joined #lisp
Bike has joined #lisp
wsinatra has joined #lisp
ex_nihilo has quit [Ping timeout: 240 seconds]
kaiwulf has joined #lisp
slyrus has quit [Remote host closed the connection]
lowryder has quit [Ping timeout: 240 seconds]
slyrus has joined #lisp
lowryder has joined #lisp
narimiran has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
rogersm has quit [Read error: Connection reset by peer]
matryoshka has quit [Read error: Connection reset by peer]
ldb has joined #lisp
matryoshka has joined #lisp
mister_m has joined #lisp
Nilby has quit [Ping timeout: 240 seconds]
flazh has quit [Quit: flazh]
retropikzel has joined #lisp
dilated_dinosaur has quit [Ping timeout: 256 seconds]
choegusung has joined #lisp
rumbler31 has joined #lisp
rogersm has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
davros_ has joined #lisp
davros_ has quit [Remote host closed the connection]
frgo has quit []
Codaraxis has quit [Ping timeout: 240 seconds]
Codaraxis has joined #lisp
ex_nihilo has joined #lisp
choegusung has quit [Quit: leaving]
luni has quit [Quit: Connection closed]
Codaraxis has quit [Ping timeout: 265 seconds]
frgo has joined #lisp
sjl has joined #lisp
frgo has quit [Client Quit]
flazh has joined #lisp
CEnnis91 has joined #lisp
frgo has joined #lisp
frgo has quit [Client Quit]
ex_nihilo has quit [Ping timeout: 240 seconds]
wsinatra has quit [Ping timeout: 240 seconds]
<pyc>
Given a relative path "foo" what is the best way to convert it to an absolute pathname, example: #p"/home/pyc/project/foo/" ?
wsinatra has joined #lisp
<jackdaniel>
(truename "foo")
<jackdaniel>
if the file exists
<pyc>
thanks jackdaniel
<jackdaniel>
or (make-pathname :name "foo" :defaults *default-pathname-defaults*) if it doesn't
<jackdaniel>
(given that your default pathname is /home/pyc/project/)
slyrus has joined #lisp
lisp-machine has joined #lisp
<pyc>
jackdaniel: yes, I will use the second option because it evaluates what I need when the directory name is a symbolic link to another path.
egp__ has quit [Quit: EXIT]
egp_ has quit [Quit: EXIT]
<pyc>
just to ensure that I am not falling in the trap of X-Y problem, here is my problem X: given a relative source path "foo" and relative target path "bar", I want to copy all files and folders recursively from "foo" and copy them to "bar".
<pyc>
so when I start walking through "foo", I get absolute paths for all files and directories found recursively, example, "/home/pyc/project/foo/dir1/file1.txt" and so on.
slyrus has quit [Ping timeout: 240 seconds]
<pyc>
so what I am going to do is resolve "foo/" to "/home/pyc/project/foo/" (the prefix), remove that from the source file path to get "dir1/file1.txt" and then append that to "bar" to get the destination path, that is, "bar/dir1/file1.txt"
dilated_dinosaur has joined #lisp
<Xach>
pyc: enough-namestring may help there
aartaka has quit [Read error: Connection reset by peer]
varjag has joined #lisp
<pyc>
What am I doing wrong here: (enough-namestring "/home/pyc/foo/bar" :defaults "/home/pyc/foo/"). Error: invalid number of arguments: 3
<Bike>
enough-namestring takes an optional parameter for the defaults, not a keyword parameter
ex_nihilo has joined #lisp
hjudt has joined #lisp
<pyc>
oops! thanks for the help Bike! I am still misinterpreting the docs even though Practical Common Lisp has taught me the difference between keyword and optional.
puchacz has joined #lisp
aeth_ has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 264 seconds]
aeth_ is now known as aeth
<semz>
I'm starting to think ITERATE is largely pointless. It's idiosyncratic with lots of gotchas, hard to extend (beats impossible I guess, but still), and purging it from my code showed that there were maybe two features I used that didn't have a direct LOOP equivalent.
toorevitimirp has quit [Remote host closed the connection]
<beach>
Yeah, LOOP works for most cases.
<lisp-machine>
hehe i've been trying to use map(c)(ar) exclusively lately as a challenge
<lisp-machine>
loopless code
<beach>
I am sorry to hear that. :)
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
<beach>
I find mapping works fine when I have the function already made, but not so practical if I have to make up an anonymous function just for the call.
<beach>
Also, if you want to collect resulting elements conditionally, mapping doesn't work.
<beach>
You get some twisted code with mapcan and listifying intermediate results.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
kam1 has joined #lisp
kaiwulf has quit [Ping timeout: 245 seconds]
varjagg has joined #lisp
nij has joined #lisp
<nij>
How to bind keys for buffer that's in dired-mode, unbind automatically when dired-mode is off, and bind automatically again if dired-mode is on again?
<nij>
OH no.. wrong place ;-(
waleee-cl has joined #lisp
ldb has quit [Remote host closed the connection]
<varjagg>
folks who build/deploy lisp applications, how do you handle project dependencies/libraries?
<varjagg>
check out 'manually' their pinned versions when staging a build?
wsinatra has quit [Ping timeout: 260 seconds]
<aeth>
varjagg: git clone into ~/quicklisp/local-projects (or ln -s there and clone elsewhere) to override the version in Quicklisp while still using Quicklisp to manage dependencies
wsinatra has joined #lisp
<varjagg>
aeth: i'm looking for a reproducible build not involving quicklisp, that means i basically have to get all of ~/quicklisp in there
<aeth>
(asdf:system-depends-on (asdf:find-system :foo)) can help but note that ASDF systems don't line up with Quicklisp projects. In general, a Quicklisp project has one or more ASDF systems which in turn has one or more CL packages. And the names don't have to line up.
ljavorsk has quit [Ping timeout: 240 seconds]
<pyc>
do you all use Quicklisp? or do you use plain ASDF?
<varjagg>
both
<pyc>
varjagg: why do you use both? why not one of them only?
<varjagg>
aeth: a practical complication is the build is a part of a broader openembedded/yocto build, it kind of has it's own fetch/configure/build flow
<varjagg>
so i really just want to write a job that grabs all dependencies in yocto fetch phase
<varjagg>
before the lisp compiler even installed
<varjagg>
guess i just need to tree-walk all asdf deps and find sources
varjagg is now known as varjag
louis771 has joined #lisp
ukari has quit [Remote host closed the connection]
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
<varjag>
pyc: qucklisp leverages asdf.. either makes sense depending where you are in dev cycle
ukari has joined #lisp
<pyc>
thanks varjag for the explanation
<pyc>
is there a function that can provide only the filenames (as opposed to absolute paths) under a directory?
gareppa has quit [Remote host closed the connection]
rumbler31 has joined #lisp
olferino has joined #lisp
<fitzsim>
varjag: that's interesting; I wanted to build a Lisp packages as part of a Yocto build a while ago
karlosz has joined #lisp
<fitzsim>
but at the time I couldn't find any lisp-related meta layers
<fitzsim>
*a Lisp package
wsinatra has quit [Ping timeout: 264 seconds]
<jackdaniel>
fitzsim: I think that buildroot had clisp
aartaka has joined #lisp
aindilis has joined #lisp
ljavorsk has joined #lisp
olferino has joined #lisp
olferino has quit [Excess Flood]
olferino has quit [Excess Flood]
olferino has joined #lisp
<pyc>
I am able to implement Unix basename like functionality with this code: (make-pathname :name (pathname-name file) :type (pathname-type file)). Does this look alright?
slyrus has joined #lisp
<jackdaniel>
looks correct at a glance, yes
<jackdaniel>
(given that the misleading name "file" means "pathname":)
meursault has joined #lisp
<pyc>
jackdaniel: thanks. let me fix that.
slyrus has quit [Ping timeout: 240 seconds]
iskander- has quit [Quit: bye]
slyrus has joined #lisp
<varjag>
fitzsim: i made a clisp layer a while ago i think
<varjag>
haven't used it much myself tbh, the project in question builds with lispworks
olferino has joined #lisp
olferino has quit [Excess Flood]
<varjag>
which is its own pain to package with yocto/qemu
mindCrime has joined #lisp
olferino has joined #lisp
olferino has quit [Excess Flood]
slyrus has quit [Remote host closed the connection]
<pyc>
Is there anyway to do this: (let ((a 1) (b (+ a 1))) (format t "a: ~a; b: ~a~%" a b)). This code of course fails with: The variable A is unbound. But I would like to know if there is a way to achieve this in another way? I want to avoid nesting 'let' within 'let'.
slyrus has joined #lisp
epony has quit [Remote host closed the connection]
<Bike>
use let* instead
<pyc>
thanks
<pyc>
one question though. why does 'let' exist at all? Can 'lambda' not achieve the same result that 'let' does?
contrapunctus has quit [Ping timeout: 272 seconds]
pranavats has quit [Ping timeout: 272 seconds]
<Bike>
sure, and you could just nest LET instead of using LET*
olferino has joined #lisp
olferino has quit [Excess Flood]
<pyc>
so is 'let' merely syntactic sugar around 'lambda'?
<White_Flame>
if you assume that the compiler is smart enough to optimize away the function construction & call, then they're equivalent
epony has joined #lisp
<pyc>
and even defuns can be lambdas assigned to a function name, right?
<White_Flame>
yes, and that is sometimes done manually
<Bike>
LET is a special operator, so an implementation can choose to implement it as a macro for a lambda form, or to handle it directly
<pyc>
so is it all just lambdas all the way down?
<Bike>
Scheme does define LET as a macro, i think
perrier-jouet has quit [Quit: WeeChat 3.0]
slyrus has quit [Ping timeout: 260 seconds]
<White_Flame>
pyc: there are a number of ways you could slice CL down to a small number of core forms, and certainly LAMBDA is one of them
<White_Flame>
but practicality means that the various patterns that one might construct from those get first-class support
<pyc>
White_Flame: what are a few others apart from lambda?
<White_Flame>
things like do you implement COND from IF, or IF from COND
slyrus has joined #lisp
<White_Flame>
and you can't directly make IF a function which calls LAMBDA. You need macro support
<White_Flame>
because calling a function object evaluates all its parameters, and IF doesn't do that
<Bike>
there are also some fiddly bits. you could define (defun name lambda-list body) to expand to `(setf (fdefinition ',name) (lambda ,lambda-list ,@body)), except most implementations give function objects names for human inspection, and the latter form may not attach a name
<pyc>
White_Flame: understood. I don't know much about lambda calculus. I have this question. is it theoretically possible to make something like 'if' or 'when' using lambda calculus?
<White_Flame>
and underlying IF/COND/CASE might be TAGBODY
<White_Flame>
then the IF implementation could choose which function to call
<Bike>
pyc: sure. you define true as (lambda (x y) x) and false as (lambda (x y) y), and then (if cond then else) is just (funcall cond then else).
<Bike>
of course that will evaluate everything, like white flame said
<White_Flame>
but then you also need some primitive which can make a choice and access 1 of 2 objects to call, which by definition is IF itself, so...
puchacz has quit [Quit: Connection closed]
<White_Flame>
I'm not huge into formal lambda calculus either, but I presume there exists a representation for it
slyrus has quit [Remote host closed the connection]
<White_Flame>
eg, (defun true (a b) a) (defun false (a b) b), such that the IF might call (funcall (funcall bool a b)) given a boolean which is #'true or #'false
slyrus has joined #lisp
iskander has joined #lisp
<White_Flame>
but then how does one convert a value into #'true or #'false using pure lambda calc? dunno :)
<Bike>
you don't convert, you just use those functions as your booleans.
<White_Flame>
how does a check for NIL work without a primitive IF?
<White_Flame>
or, numeric less-than?
olferino has joined #lisp
puchacz has joined #lisp
olferino has quit [Excess Flood]
<White_Flame>
meaning, at runtime the system has to choose #'true or #'false based on non-boolean inputs
<White_Flame>
so at this point, one simply turns to practicality and the functionality that the CPU/environment already supplies, regardless of lambda calc, and handwave such things away :)
<White_Flame>
(or start implementing church numerals etc)
<White_Flame>
purity has its cost
<Bike>
i mean, yeah, you do all that stuff in church encoding. it's doable, if not practical
olferino has joined #lisp
slyrus has quit [Ping timeout: 245 seconds]
olferino has quit [Excess Flood]
iskander has quit [Client Quit]
<White_Flame>
I shudder to think what the floating point equivalent of church numerals would be
<White_Flame>
or string implementations
<White_Flame>
(well, strings would probably be easier, just a cons list of church numerals)
olferino has joined #lisp
olferino has quit [Excess Flood]
Bourne has quit [Ping timeout: 265 seconds]
olferino has joined #lisp
olferino has quit [Max SendQ exceeded]
olferino has joined #lisp
olferino has quit [Excess Flood]
karlosz has quit [Ping timeout: 264 seconds]
<pyc>
given a relative directory path say "foo/bar/baz/", what is a good way to extract "baz/" out of it? Is there a pathname function to do that? Looking for something similar to shell's basename foo/bar/baz/.
<Xach>
pyc: look at the pathname-directory components
olferino has joined #lisp
olferino has quit [Excess Flood]
meursault has quit [Quit: Leaving]
<pyc>
Xach: thanks. so I arrived at: (last (pathname-directory "/foo/bar/baz")). It returns "baz". How can I force it to become "baz/" so that it represents a directory path?
sauvin has quit [Read error: Connection reset by peer]
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
Oladon has joined #lisp
anticrisis has joined #lisp
Christ0pher is now known as anunnaki
<Alfr>
pyc, as you seem to have decided to go down the pathname rabbit hole w/ all of its "Complicated defaulting behavior", you might consider reading: