verisimilitude has quit [Remote host closed the connection]
Kaisyu7 has joined #lisp
marusich has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
Oladon has quit [Quit: Leaving.]
mejja has quit [Quit: mejja]
hectorhonn has joined #lisp
<hectorhonn>
morning everyone
<LdBeth>
morning
dgtlcmo has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
igemnace has joined #lisp
MichaelRaskin has quit [Read error: Connection reset by peer]
pjb has quit [Read error: Connection reset by peer]
scottj has joined #lisp
Achylles has quit [Ping timeout: 240 seconds]
pjb has joined #lisp
buffergn0me has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
Jesin has joined #lisp
Arcaelyx has quit [Ping timeout: 250 seconds]
djuber has joined #lisp
hectorhonn has quit [Quit: Page closed]
hectorhonn has joined #lisp
akoana has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
markoong has quit [Ping timeout: 246 seconds]
xealits has joined #lisp
xealits has left #lisp [#lisp]
xealits has joined #lisp
xealits has left #lisp [#lisp]
djuber has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]
buffergn0me has joined #lisp
Oladon has joined #lisp
keep_learning has joined #lisp
gravicappa has joined #lisp
CCDelivery has quit [Remote host closed the connection]
parjanya has joined #lisp
marvin3 has joined #lisp
marvin2 has quit [Ping timeout: 268 seconds]
dacoda has joined #lisp
dgtlcmo has quit [Ping timeout: 246 seconds]
verisimilitude has joined #lisp
<montxero>
Perhaps not the best place for this but I reckon this group has the requisite knowledge. Why do people (training consultancies) charge $1500+ for a 2 to 8 day introduction to `x-lang`?
<montxero>
especially given that they do not (cannot) cover any substantial amount of material in that time
<p_l>
montxero: because that's a cost just to hire the trainer plus logistics plus *some* profit
<p_l>
Depending on language and class of people involved you can, however, make a significant dent
<p_l>
By carefully managing both expectations AND grade of people taking part in training it's perfectly possible to make a week long course that kick starts a team on new language
<verisimilitude>
With the Internet existing, along with a wealth of books, there's no reason to purchase such, montxero.
<verisimilitude>
There's this saying: A fool is easily parted from his money.
<montxero>
p_l: okay, if that be the case why bother with competent devs in the first place as a new crop can be harvested that easily
<montxero>
verisimilitude: ergo my shock
<verisimilitude>
Just look at modern bootcamps, montxero.
<p_l>
montxero: what you're missigg is that it doesn't mean you don't need competent devs in the first place
<montxero>
a bit of background, I muck around with python, matlab, and I'm learning common lisp
<p_l>
They need to be competent to finish the training in such pace
<montxero>
I do not consider myself a "dev"
<verisimilitude>
You collect a band of idiots looking for easy money, set them up in stupid little classes for JavaScript or any programming language that doesn't matter, and you send them to California for the gold rush, where they get ripped to shreds.
<montxero>
however, I am more than conversant with all the intermedeate materials in the python courses I've seen
<p_l>
I'll give example from my own curriculum
<p_l>
The requirements are competent, but not masterful (those can do it with a page of docs and an evening) sysadmins that know linux and can handle Bash scripting
<p_l>
The course then takes them through a bit of theory about "cloud" and "infrastructure as code"
<montxero>
p_l: uh huh
<verisimilitude>
I don't think it's a controversial idea that only people with a real interest in programming should be writing programs. We don't expect someone without an interest in mathematics to write an elegant proof and advance the field; let's just disregard financial math, which is mostly concerned with transferring money from you to me indirectly.
charh has quit [Ping timeout: 245 seconds]
<p_l>
Later on using a simple "wargame" they are walked through all the steps necessary to bring up a common application example in the cloud, using purely IaC approach
<hectorhonn>
what's the de facto common lisp logging library/facade?
aindilis has quit [Ping timeout: 240 seconds]
<beach>
Good morning everyone!
<verisimilitude>
There's DRIBBLE, hectorhonn.
<verisimilitude>
As in, CL:DRIBBLE.
makomo has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
<montxero>
verisimilitude: That's $200 right there
<p_l>
montxero: this is all actionable stuff where they are doing coding on both days and which concentrates on getting things done and pointing where to go from there
aindilis has quit [Remote host closed the connection]
<montxero>
p_l: fair enough.
<p_l>
montxero: this means that anyone who participates seriously should be able to go back to work and start an onprem->cloud migration, including understanding why and why NOT, while keeping to best practices
<p_l>
And having a chance to later grow themselves
<p_l>
beach: morning!
<hectorhonn>
verisimilitude: no, i want to log to both console and file
aindilis has joined #lisp
<verisimilitude>
If DRIBBLE isn't quite what you want, then I have no answer, hectorhonn.
<p_l>
hectorhonn: unfortunately there's nothing standard like in Java
<p_l>
There are many logging libs that handle it in various ways
<verisimilitude>
I'm inclined to believe one shoulddn't use a programming language until one actually knows it.
<verisimilitude>
If you don't read the standard, you probably don't actually know the language.
<p_l>
verisimilitude: that would exclude pretty close to all C/C++/Python and bunch of other languages
<verisimilitude>
Yes, for good reason, p_l.
<verisimilitude>
Look at the above article; instead of actually knowing the language, this fool writes a test to check his ``hypothesis''.
<montxero>
p_l: Thanks for clearing that up. Say I have some specialied knowledge which I incidentally implement in a programming language, can I in all honesty offer a course such as: Developing `super niche hyper cool Y` in `x-lang`?
<p_l>
Python would die by virtue of not having a standard at all
Bike has quit [Quit: Lost terminal]
<p_l>
montxero: probably depends on the niche, and I'd focus on the niche rather than language
<verisimilitude>
It's an issue if people are writing programs that only happen to work correctly and, worse, don't even understand what they're actually doing, because of this.
<montxero>
p_l: developing and implementing functional observers for various classes of systems: a bit too niche
<p_l>
verisimilitude: I believe ability to program is separate from knowing the language
charh has joined #lisp
<p_l>
At least my experience so far seems to support that
<p_l>
And often you hit issues of not knowing non-programming bits
<montxero>
verisimilitude: remind me to pass my blog ideas by you before publication, I appreciate honest critque
<p_l>
Like developers writing network services having no idea about basics of IP
<verisimilitude>
Would you like my email, montxero?
<verisimilitude>
Also, show me your blog.
<verisimilitude>
If you're working with an abstraction, then you should just need to understand it alone, p_l, such as how things can fail.
<montxero>
verisimilitude: yes please I would like your email. I haven't started the blog yet, just a bunch of ideas. I'd start after submitting my thesis
Necktwi has quit [Quit: leaving]
<verisimilitude>
Here's my current email: programmer@verisimilitudes.net
<verisimilitude>
Using ``programmer'' was more appealing to me than using ``admin''.
<verisimilitude>
Also, I agree that ability to program at all is separate from any particular language, but one shouldn't use a language one doesn't know.
<verisimilitude>
I'm curious how many of you went about learning Common Lisp; I learned by reading CLtL2, a list of final changes with the standard, and I've read other nice books since.
buffergn0me has quit [Remote host closed the connection]
<p_l>
What was successful was PCL plus having hyperspec linked in emacs
<p_l>
That said, the path to making PCL successful involved Haskell
<montxero>
Recursive functions of symbolic expressions and their computation by machine, part I: that was(is) the hook
libertyprime has quit [Ping timeout: 244 seconds]
<montxero>
I started writing (pen on paper) functions in the S-function syntax from the paper
<montxero>
after a while (couple of months), I wanted to run the larger ones (as manual tracing became tedious)
<montxero>
I stumbled on SICP, and PCL. installed emacs.
<montxero>
PCL was too practical for me, so I did'nt get past the first chapter. I wanted something along the lines of the paper so I started SICP with common lisp
<montxero>
ran into some problems, then someone here told me to stop nested `defuns` as that is a schemeism not a common lisp idiom
<montxero>
so now, I'm working through a gentle introduction to commonlisp in my spare time
dale has quit [Quit: dale]
buffergn0me has joined #lisp
<montxero>
if I were to pa $2000 for a 2 day lisp course (where the lesson is not there ain't no shortcut), I would expect to be banging out sonnatas by the end of day 2. I should be able to write a prolog interpreter, library for implementing dependent types complete with a dsl for point free programming in lisp by the end of day 2
<montxero>
seeing as I am a lone learner that is
dddddd has quit [Remote host closed the connection]
<beach>
montxero: There is some missing information here. First, there might be several participants, so per participant it is not much money. Second, that amount of money is peanuts to most corporations. Third, going to a course is not always meant to be a training thing, but a reward. Participants look good in the eyes of their colleagues.
<verisimilitude>
So, you're arguing the social signalling angle, beach?
charh has quit [Ping timeout: 268 seconds]
<beach>
I am merely explaining why corporations are entirely willing to pay this fee.
<montxero>
AUD1760 per person 2 days this is not some Dave Beazely level program https://pythoncharmers.com/training/introduction-to-python/#details. I see p_l's point, and I agree that this will be great if covered by the organisation. Now I dare not check for one in common lisp can you imagine a recursively defined price tag with unwind protect when you want to back out?
parjanya has quit [Remote host closed the connection]
prite has joined #lisp
parjanya has joined #lisp
charh has joined #lisp
<verisimilitude>
I wonder what the catering's like in these classes.
<no-defun-allowed>
I'm not sure if one can thoroughly learn all that (even in Python) in two days. Maybe if each session spans most of the day, but that's not very likely.
akoana has left #lisp ["Leaving"]
<verisimilitude>
I read CLtL2 in the same way I read other dense technical books, across several months, reading some chapters in a day or so and spending weeks in the interim not reading the book at all. I doubt one could learn a large language in a single day.
<verisimilitude>
One could learn a good Forth in less than an hour, but Forth isn't a large language; with my limited knowledge of SQL, I suppose you could probably learn that in a day or two if you wanted.
<montxero>
p_l: charging such amount for training on using a tool/program/technology or technology is different from an introduction to programming training. A tool (from here on refers to something akin to a device not including pl) may be mstered in a relatively short period and may not be used too often. Often one only needs docs/manuals and a some tutorials to be on their way. Moreover the returns on time spent
<montxero>
on learning a tool is usually realised quicker than time spent on a programming language. A programming language brings with is certain idioms and ways of doing things that are not necessarily easily transfered to other languages
<p_l>
montxero: this is more a question of curriculum design
<p_l>
For example, the one you linked to me feels a bit rushed
<montxero>
Since the prodcutivity of a tool can be realised quickly the upfron cost can be justified more easily
<montxero>
p_l: my point exactly, will you give a common lip for pythonistas course in 3 days?
<p_l>
I'd argue more, to unlearn Python
<montxero>
they have some courses that do not seem bad, like the predictive analysis one. That seems fair enough but a in introduction to the language...
<montxero>
p_l: hahahaha
Necktwi has joined #lisp
<pillton>
p_l: "the path to making PCL successful involved Haskell"?
<no-defun-allowed>
[random Haskell line] see, you could be learning this instead of Common Lisp!
<p_l>
pillton: I did mention unlearning Python, didn't I? In my case it wasn't Python, but experience with Haskell helped dislodge some mental blocks I encountered with CLOS
<p_l>
(and CL in general)
<akater>
hectorhonn: Concerning logging, I just recently heard of log4cl.
<pillton>
p_l: I thought there was some anecdote involving Peter Seibel and Haskell and the road to PCL.
hiroaki has quit [Ping timeout: 268 seconds]
megalography has joined #lisp
<beach>
montxero: I must have missed the beginning. What is your problem with this price for a course?
Oladon has quit [Quit: Leaving.]
Arcaelyx has joined #lisp
Necktwi has quit [Quit: leaving]
nicball has joined #lisp
esrse has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
space_otter has quit [Remote host closed the connection]
nicball has quit [Remote host closed the connection]
Inline has quit [Quit: Leaving]
nowhereman has joined #lisp
orivej_ has quit [Ping timeout: 245 seconds]
mange has quit [Remote host closed the connection]
nowhereman has quit [Ping timeout: 252 seconds]
megalography has left #lisp [#lisp]
mingus has quit [Ping timeout: 272 seconds]
pierpal has quit [Ping timeout: 268 seconds]
amerlyq has quit [Quit: amerlyq]
schjetne has quit [Ping timeout: 250 seconds]
jprajzne has joined #lisp
scymtym has quit [Remote host closed the connection]
pierpal has joined #lisp
<hectorhonn>
akater: thanks, i'll check it out
akater has quit [Remote host closed the connection]
akater has joined #lisp
<akater>
Something I did not realize: change-class will make shared slot unbound if class C_to has no initform for it.
<akater>
Hence, when superclass has initform and subclass has not, super->sub will retain the value (even though e.g. its type check could fail)
<akater>
while subclass->super will not (even though type check would never fail in this case).
<akater>
*never --- presuming types are static.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<akater>
oops, I transposed it: was talking about the case where superclass has no initform but subclass is more specific
milanj has joined #lisp
<hectorhonn>
what are some notable libraries written in common lisp? for example, c++ has opencv
<hectorhonn>
im trying to promote common lisp
<shka__>
postmodern
<shka__>
screamer ;]\
<shka__>
optima
<shka__>
petalisp is really cool on many levels
<akater>
Why people recommend optima and not trivia?
<shka__>
i never used trivia myself
<shka__>
so i don't have comparsion
<akater>
I never used optima. From what I remember, trivia is an almost superset of optima, +enhancements.
<shka__>
hm, i would have to check it out it seems
varjag has joined #lisp
<shka__>
hectorhonn: i think that petalisp can be really cool posterboy of cl libs because of high coolness factor
<shka__>
duh
<shka__>
;-)
<akater>
fare even made some effort for trivia to “officially” supersede optima, as far as this is makes sense in CL.
<shka__>
ah
<shka__>
oh, right
charh has quit [Ping timeout: 250 seconds]
<shka__>
hectorhonn: since akater mentioned Fare, LiL
<jackdaniel>
"your library is obsolete, use mine mine mine"
<jackdaniel>
,)
<akater>
well, fare was on some quest for unification
<shka__>
LiL is rather interesting example of cl style design
<akater>
(Some time ago, and he wrote about it in his LiveJournal.)
<shka__>
maybe atypical though
<shka__>
as for really compact example i guess cl-graphviz is very neat
<shka__>
or even shorter: cl-dot
<akater>
Does anyone actually understand LIL, besides fare? Only half joking, I never found any write-ups, or libraries which use it.
<hectorhonn>
maybe i should rephrase.. what are some notable libraries written in common lisp that are de facto libraries in that niche? for example, c++ has opencv which is de facto in the computer vision field
<akater>
hectorhonn: Kenzo? :-)
<parjanya>
this looks like a very interesting list, with descriptions &c
<beach>
hectorhonn: I suggest you avoid promoting Common Lisp unless you know in detail what you are talking about and what the competition looks like. Otherwise, you will likely get trashed and the result will not be advantageous to Common Lisp.
<akater>
I don't think there's anything de facto standard in CL, in a way which would be convincing for people who need CL to be promoted to them.
<beach>
That too.
<hectorhonn>
akater: Constructive Algebraic Topology? that is some advanced stuff ><
<hectorhonn>
beach: good point
<akater>
hectorhonn: Well, I'm not sure if this could be described as “de facto standard” but there's a chance there's no alternative.
<akater>
Also in similar field, Sheafhom
<parjanya>
it should be fine if you avoid... boasting about it
charh has joined #lisp
<akater>
I never tried any of those
<hectorhonn>
hmm, haskell has parsec
_whitelogger has joined #lisp
<akater>
CL is curiously hard to sell (to “people on the street”, that is). People keep saying something about parenthesis or how lists are stupid (and arrays are not).
amerlyq has joined #lisp
asarch has joined #lisp
<asarch>
One very very stupid question: Can PortableAllegroServe do REST?
<akater>
It's a riddle, really. I better spend time writing something cool and just telling facts about the standard and the community.
<beach>
akater: I completely agree with you.
<hectorhonn>
nod nod
<shka__>
if lisp was about lists…
<beach>
shka__: People stick to what the belief that will make it unnecessary for them to learn something new.
<shka__>
true
<shka__>
well, truth be told we really just need libs, not popularity
<beach>
shka__: My (admittedly small) family recently had an exchange with a former colleague who thought Lisp was not used these days. When she pointed out Grammarly, ITA, Roomba, etc., the colleague immediately answered that Haskell would be better. So this professional developer assumed Common Lisp is a functional programming language. Convenient for him.
<beach>
shka__: I agree. We need more software. Not just libraries. Applications too.
<shka__>
yes
schjetne has joined #lisp
<shka__>
if you can make piece of software instead of complaining about it
<beach>
Working on it.
<shka__>
heh, same here
<no-defun-allowed>
yep, same here too
schweers has joined #lisp
makomo has joined #lisp
<beach>
With respect to applications, I really should get started on Clovetree (a.k.a. Gsharp version 2).
<beach>
McCLIM is way more mature now and it has facilities that weren't available at the time, in particular for using Truetype fonts.
<beach>
Now, with display resolutions no longer being a problem, I could use an existing Truetype font which would greatly simplify the code.
<beach>
It can't be an improvement to Gsharp, because I made a design mistake that I mean to fix in Clovetree.
<beach>
Together with Climaxima, we would then have two significant applications that are fairly unique.
hhdave has joined #lisp
<dim>
GuitarPro (not lisp, not Open Source, made by a local French company) has pushed the bar way far for parts editing for the guitar...
<dim>
I still believe there's an low-handing opportunity for CL in publishing “infrastructure” software rather than interactive software, maybe something that would help taming some of the Cloud offerings, dunno
<shka__>
i had to check how gsharp looks
<shka__>
fonts rendering in new mcclim is seriously improved
<shka__>
like a lot
<beach>
shka__: It doesn't look very good. Its unique feature is related to how it is used.
<shka__>
beach: i was contemplating improvements in the mcclim itself
<makomo>
morning
<beach>
shka__: Looks can always be fixed by others. I am uniquely well placed to implement the essential data structure for making the editing experience possible.
<shka__>
once i get my data-frame library operational, i will have to create viewer for it
<shka__>
should be simple way to learn clim
<beach>
shka__: Sure, but Gsharp doesn't use McCLIM font rendering at all, because of the environment at our disposal some 18 years ago.
<beach>
Hello makomo.
<shka__>
beach: ah!
<shka__>
ok
<schjetne>
beach: that's another one I have to show the product owner here. He got curious by me harping on about Common Lisp all the time, and found Common Music, so I showed him Opus Modus as well.
<schjetne>
He's a musician as well as engineer
<beach>
Nice!
asarch has quit [Quit: Leaving]
<beach>
schjetne: If the product owner and others are ripe, I'll be happy to come give a talk about Common Lisp, or a full-day course or something. :)
<schjetne>
He might follow along to ELS and we can talk in person
<beach>
Oh, that's a great idea.
imjacobclark has joined #lisp
imjacobclark has quit [Remote host closed the connection]
froggey has quit [Ping timeout: 240 seconds]
<schjetne>
I've been doing a lot of work with DSLs lately, which might be an argument to look into Common Lisp
<beach>
Sounds good to me.
imjacobclark has joined #lisp
<hectorhonn>
schjetne: absolutely agree, cl is very good for writing dsl because of macros
imjacobclark has quit [Remote host closed the connection]
<beach>
So the mistake that most engravers (or score editors) make is to impose a meter on each measure. It's a mistake because it is a pain to edit then. Plus, composers are known not to respect the meter in their written music. That's why Gsharp is much faster when it comes to entering music material.
froggey has joined #lisp
<no-defun-allowed>
Oh, I've heard about the "macros" in Kotlin before. From what I've heard, they emulate stuff like WITH-OPEN-FILE with a function that takes a function that takes the managed value, and some prologue and epilogue is handled by the "macro" writer.
<beach>
schjetne: What is the relationship between the "product owner" and your employer?
<schjetne>
He's one of the founders of the company
<no-defun-allowed>
This, depending on how many macros you've actually used, is either a hygenic macro system (macros ≈ 0), a horrendous kludge (macros > 0, sad person) or the way Smalltalk and Ruby handle it (macros > 0, maybe not as sad of a person)
<beach>
schjetne: I see, and still part of it?
imjacobclark has joined #lisp
<schjetne>
beach: he is
imjacobclark has quit [Read error: Connection reset by peer]
<no-defun-allowed>
It has an equivalent effect to a very boring macro.
<schjetne>
It's fine for trivial things, for non-trivial cases it becomes all kinds of trouble, when you can't programatically create identifiers.
<no-defun-allowed>
Yup.
hectorhonn has quit [Quit: Page closed]
pierpal has quit [Ping timeout: 246 seconds]
mingus has joined #lisp
jprajzne has quit [Ping timeout: 245 seconds]
mange has joined #lisp
libertyprime has joined #lisp
jdz has quit [Ping timeout: 252 seconds]
<p_l>
beach: btw, have you looked at opusmodus?
<beach>
I just did :)
<beach>
I haven't used it though.
<p_l>
I'm not knowledgeable about music enough to do anything with it, but it looks like a nice example of good, end-user oriented Common Lisp applicaiont
<p_l>
*application
<p_l>
also, we should mention SISCOG and maybe even gensys more?
<beach>
You may be right. I'll have to investigate further.
robdog_ has joined #lisp
<beach>
Maybe so, yes.
jdz has joined #lisp
robdog_ has quit [Remote host closed the connection]
robdog_ has joined #lisp
<p_l>
also, from ELS in Cracow or London, there was a talk about some nice OpenCL-based work that was greatly optimized thanks to facilities enabled by CL
robdog_ has quit [Remote host closed the connection]
<jmercouris>
So I have a file upload form on my website, and that returns me a object like this: #<FLEXI-STREAMS::VECTOR-INPUT-STREAM {1003014B23}>
<jmercouris>
one would logically think, based on the documentation of cl-csv https://github.com/AccelerationNet/cl-csv that you would be able to read this input stream
<jmercouris>
however this is an input stream composed of octets
<jmercouris>
the character format is unknown, but let's just assume it is latin1
<jmercouris>
or some basic ascii
<jmercouris>
how can I get cl-csv to actually read it? I tried flexi-streams:octets-to-string, but that requires a string
<_death>
make-flexi-stream
<jmercouris>
so then I did alexandria:readm-stream-content-into-string first, but then it didn't work
<jmercouris>
_death: I will give that a try, thank you
robdog__ has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
<jmercouris>
_death: that worked great, thank you!
<jmercouris>
so a stream is not a flexi-stream
<jmercouris>
but a flexi-stream can be made from a stream
<jmercouris>
and cl-csv I guess, is expecting a character stream
<jmercouris>
which is what flexi-stream convert the octet stream to
<jmercouris>
am I understanding all of this correctly?
<_death>
the vector-input-stream is a binary stream, and make-flexi-stream can make a bivalent stream reading from it
schweers has quit [Remote host closed the connection]
m00natic has quit [Ping timeout: 268 seconds]
robdog_ has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
rippa has joined #lisp
amerlyq has joined #lisp
loli has quit [Ping timeout: 244 seconds]
<beach>
Since things are quiet here, ... A few hours ago in the #clim channel, I was inquiring about the possibility of implementing a "desktop environment" in Common Lisp such that it could work both on a GNU/Linux machine running X11 and Gnome and on some ultimate Lisp operating system.
<beach>
As it turns out, I am pretty ignorant about how such an environment would work. But it seems to me that the basis of such a thing would be a window manager, perhaps coupled with a workspace switcher.
<beach>
I am aware of Stumpwm, but I am not aware of a recent non-tiling window manager. As it turns out, though, my students wrote such a thing some 15 years ago, called Eclipse, but it hasn't been worked on for the past 8 or so years.
<beach>
If someone with knowledge about desktop environments would be interested in reviving Eclipse (and perhaps giving it a better name), I would encourage it. :)
<flip214>
beach: doesn't it "just work" even now? Do you have bug reports?
sky4 has joined #lisp
<beach>
I don't know. It might very well work. But I suspect it is not entirely conforming when it comes to all the X11 conventions that a window manager must follow.
<beach>
I also don't know whether it could just replace the default window manager that I am using on Ubuntu, or what it would take to make that possible.
<beach>
I take it [-] means there is work to be done.
sky4 has quit [Client Quit]
<djeis[m]>
Yea, although it looks like a lot of the important EWMH stuff is done.
<beach>
That's good.
Necktwi has quit [Ping timeout: 240 seconds]
xkapastel has joined #lisp
<Josh_2>
Any reason why I might be picking up a null character when sending data over the network?
<Josh_2>
The start of my string which is sent over the network has a #\nul and #\! at the start even though that is not present on the sending side
<Josh_2>
I'm using usocket for the conneciton
<dlowe>
both sides of the connection?
<Josh_2>
Nope, the sending side is java
<dim>
beach: I was at school with Iban Hatchondo in Bordeaux in 1st year of university eons ago, but then I moved to other places… fun to see his name again ;-)
<Josh_2>
perhaps it is because it is sent using UTF
<Josh_2>
*as utf
<p_l>
Josh_2: UTF-16/UCS-2?
<Josh_2>
UTF-8
<p_l>
if so, 8-bit-fitting characters will have a null byte after them
<p_l>
UTF-8 doesn't leave null bytes around
FreeBirdLjj has quit [Remote host closed the connection]
<p_l>
Josh_2: can you show the code on the java side?
<tempate>
beach: how can the function-call semantics not work?
<Josh_2>
p_l: oof
<Josh_2>
Thanks :)
<beach>
tempate: If you don't want all the arguments to be evaluated before the call.
<Josh_2>
I will change to bufferedoutputstream
<tempate>
hmm, I see
<beach>
tempate: So for instance, WHEN can not be written as a function.
<phoe>
same about SETF
<phoe>
or INCF or DECF
<beach>
tempate: The advice from jackdaniel is correct, but more general. A function may very well work for some boilerplate code.
<tempate>
as I understand them, macros take code and return code
<phoe>
yep
<beach>
Correct.
<tempate>
coming from C, I don't really think in those terms, so when coding I think in terms of functions taking arguments and spitting results
<tempate>
I would like to think in more lispy terms so to speak
Necktwi has joined #lisp
milanj has joined #lisp
<dlowe>
Think of it as a compiler plugin that will generate code for you
<dlowe>
except instead of munging text you can munge trees of objects
<dlowe>
also, feel free to join #clschool if you'd like
<tempate>
what is it for?
<phoe>
imagine if the C compiler could generate code that looks like loop { for x from 0 to 10; for y = 2 * x; do { printf("%s %s\n", x, y); }; finally return 42; }
<phoe>
s/generate/understand/
<phoe>
that's more or less what Lisp macros allow you to do with the syntax, since this is exactly how Lisp's LOOP macro works
<tempate>
hmm
ggole has quit [Remote host closed the connection]
<tempate>
I mean, I understand it on paper, but I don't know when I should be using them
ggole has joined #lisp
<phoe>
whenever you need to
<beach>
tempate: In the same situation you would use C macros.
<phoe>
some things simply cannot be done by functions, such as x++ or (incf x)
<beach>
tempate: Except that Common Lisp macros are sane because they work on code as a data structure instead of text.
<tempate>
ok
<tempate>
got it
<tempate>
they are the upgraded version of C macros, sort to speak
<beach>
Sort of.
Necktwi has quit [Ping timeout: 250 seconds]
<phoe>
or rather, C macros are the stunted version of Lisp macros
<beach>
tempate: You can think of functions as control abstractions, classes as data abstractions, and macros as syntactic abstractions.
<beach>
tempate: I.e., they allow you to create new syntax.
<djeis[m]>
It's like if you could write C macros in C and they took a datatype more useful for manipulation than just strings.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<phoe>
C macros are interpreted by the C preprocessor and therefore have very limited abilities; Lisp macros are interpreted by the same Lisp engine that powers the rest of the system and therefore can use all of Lisp functionality to generate Lisp code.
<shka__>
C macros aren't really C
<phoe>
that allows you to use e.g. functions, classes, other macros, to generate Lisp code inside a macro.
<phoe>
it's a pleasant synergy.
status402 has quit [Quit: status402]
<tempate>
alright
<tempate>
I think I understand
<tempate>
thanks
lumm has joined #lisp
gareppa has joined #lisp
gareppa has quit [Max SendQ exceeded]
Inline has joined #lisp
gareppa has joined #lisp
makomo has joined #lisp
wusticality has joined #lisp
lumm has quit [Read error: Connection reset by peer]
<tempate>
as an example, I'm trying to solve a couple exercises from L99. My current solution is https://bpaste.net/show/46ce5dc6ed84 but I have the feeling this could be done in a way better way, as the second and third functions are pretty much the same, and the last one, is looping through the list three times, which doesn't seem to be very good
lumm has joined #lisp
wusticality has quit [Ping timeout: 244 seconds]
<phoe>
do (foo) and do (bar) and do (baz) === do (foo) (bar) (baz)
Necktwi has joined #lisp
pfdietz has joined #lisp
<phoe>
other than that this code is nice
<beach>
tempate: Maybe, but it has already been done for you. Use LOOP and COLLECT.
<phoe>
or use LOOP's COLLECT like beach suggests if you don't want to deal with collection manually
<tempate>
phoe: oh, wasn't aware of that
ebrasca has joined #lisp
<tempate>
yeah, it seemed I good place to use COLLECT but I wasn't too sure on how to use it, let me look at it more deeply
lumm has quit [Quit: lumm]
<tempate>
beach: still, even if I use LOOP, wouldn't I be looping through the whole sequence three time if I run the third function?
lumm has joined #lisp
loli has quit [Ping timeout: 246 seconds]
<beach>
Sure.
gareppa has quit [Quit: Leaving]
<beach>
Er, wait.
<phoe>
depends on where you use it
<beach>
What makes you think the third function traverses the list three times?
Necktwi has quit [Ping timeout: 240 seconds]
<beach>
tempate: Are you trying to merge what length-encoding and simple-encoding do?
<beach>
tempate: Sure, you can combine the three functions, but that's not a question of using macros or not.
<tempate>
phoe: not sure if the default syntax should be to put the do after the if, i.e. if do, or just have the do in front of the first thing to do
<beach>
tempate: Always put the loop keyword first on a line.
<beach>
tempate: But you need slime-indentation to get the indentation of conditional loop clauses right.
<tempate>
beach: couldn't I write a macro that loops through the whole sequence and then add the inside of what to do depending on which function is running it?
<tempate>
how was slime-indentation run on emacs again, beach?
<beach>
In your .emacs, when you do slime-setup.
Necktwi has joined #lisp
<beach>
tempate: Sure, you can even write a function that does that. There are several, like MAP, MAPCAR, etc.
<beach>
tempate: But basically, you are just describing what LOOP FOR .. IN does.
<tempate>
beach: I'm not sure I'm following
robdog_ has joined #lisp
<tempate>
beach: what do you mean I'm describing what LOOP FOR .. IN does?
<tempate>
beach: as I understand it, if I run the third function, three loops are going to take place
<beach>
"a macro that loops through the whole sequence and then add the inside of what to do depending on which function is running it" seems like a good description of (LOOP FOR .. IN ...).
<tempate>
oh, I see
<beach>
tempate: Yes, when you run the third function, the other two are going to run as well.
<phoe>
(loop for x in list if (foo x) do (bar x) else do (baz x))
<tempate>
beach: and couldn't this be optimized with macros somehow?
<phoe>
LOOP already is a macro
<phoe>
and you could reimplement your whole set of three functions as a single LOOP
<phoe>
that would allow you to only traverse the list once
loli has joined #lisp
<beach>
tempate: I think it will be hard to write any kind of abstraction that takes your three LOOP bodies and combines them so as to avoid creating intermediate lists, if that is what you mean.
<tempate>
that's what I would like
<tempate>
beach: yes, that's exactly what I meant
robdog_ has quit [Ping timeout: 240 seconds]
<tempate>
oh, ok. Never mind then
<tempate>
thank you both for the help
<beach>
Sure.
asarch has joined #lisp
travv0 has left #lisp [#lisp]
Necktwi has quit [Ping timeout: 272 seconds]
robdog_ has joined #lisp
robdog__ has joined #lisp
<nirved>
tempate: instead of first and second you could use the loop built-in destructuring - (loop :for (count element) :in ...)
<tempate>
oh, nice
robdog_ has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
<tempate>
nirved: if you are referring to the third function, I need to sometimes return the list containing both the first and the second element, so I'm not sure if it's worth it
<tempate>
still, I wasn't aware that could be done, so thanks for the advice
robdog_ has joined #lisp
robdog__ has quit [Ping timeout: 240 seconds]
amerlyq has quit [Quit: amerlyq]
lumm has quit [Remote host closed the connection]
<tempate>
nirved: what are the : for?
lumm has joined #lisp
lumm has quit [Remote host closed the connection]
lumm has joined #lisp
<nirved>
tempate: i use keywords with loop for syntax highlighting, and less symbol pollution
robdog_ has quit [Ping timeout: 240 seconds]
<tempate>
fair enough
lumm has quit [Client Quit]
lumm has joined #lisp
orivej has quit [K-Lined]
robdog_ has joined #lisp
sjl has joined #lisp
nowhereman has joined #lisp
robdog__ has joined #lisp
marusich has quit [Remote host closed the connection]
tempate has quit [Quit: Leaving.]
robdog_ has quit [Ping timeout: 240 seconds]
robdog__ has quit [Ping timeout: 240 seconds]
robdog_ has joined #lisp
shka_ has joined #lisp
q3d has quit [Quit: Page closed]
robdog_ has quit [Ping timeout: 240 seconds]
hhdave has quit [Quit: hhdave]
lumm_ has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
lumm_ is now known as lumm
Necktwi has joined #lisp
lumm has quit [Client Quit]
lumm has joined #lisp
lumm has quit [Client Quit]
robdog_ has joined #lisp
lumm has joined #lisp
Essadon has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
Necktwi has quit [Ping timeout: 240 seconds]
Necktwi has joined #lisp
loli has quit [Ping timeout: 244 seconds]
ravenousmoose has joined #lisp
robdog_ has joined #lisp
karlosz has quit [Quit: karlosz]
jmercouris has joined #lisp
<jmercouris>
I'm trying to load cl-dbi with postgres, but I have an interesting error
<jmercouris>
Ah, my stupidity, didn't realize the ql made the issue, problem solved, thanks rubber duck
loli has joined #lisp
<dim>
jmercouris: what's better in cl-dbi compared to Postmodern?
Necktwi has quit [Remote host closed the connection]
robdog_ has joined #lisp
ravenousmoose has quit [Quit: Taking a quick nap...ZZzzz]
<jmercouris>
I'm not sure, I just cl-dbi because it is agnostic
<jmercouris>
maybe Postmodern is better, but I'm not married to postgers
<jmercouris>
s/postgers/postgres
robdog_ has quit [Ping timeout: 240 seconds]
robdog_ has joined #lisp
Necktwi has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
wusticality has joined #lisp
dgtlcmo has quit [Ping timeout: 272 seconds]
lumm has quit [Ping timeout: 252 seconds]
lumm has joined #lisp
robdog_ has joined #lisp
dgtlcmo has joined #lisp
<dim>
I think making a solid choice of a RDMBS and then using as many features it can provide is a good move (the smart one, I'd argue), so my advice is to pick Postgres and Postmodern
<dim>
(you do whatever you want with my advice of course)
lumm has quit [Read error: Connection reset by peer]
wusticality has quit [Ping timeout: 272 seconds]
lumm has joined #lisp
karlosz has joined #lisp
<dim>
in the wild changing from an RDBMS to another usually happens up to one time in a project's lifetime, and it's a major undertaking; unless you *have* to support several RDBMS backends at the same time, being _portable_ in between them is not going to prove interesting ever
<shka_>
indeed
emaczen has joined #lisp
<shka_>
furthermore there is little reason to not use postgres
<shka_>
it is just good
<dim>
it's much harder and way more involved to be SQL-portable that to be compliant with several CL implementations, say, despite both CL and SQL having a standard specification
<dlowe>
The SLQ spec is more akin to the Scheme spec, where there's bare bones that everyone piles their own stuff onto
<dlowe>
SQL spec
robdog_ has quit [Ping timeout: 250 seconds]
<shka_>
not even that
<emaczen>
How do we enable/find the SBCL source code so that emacs can M-. to source locations?
<emaczen>
I mean SLIME mode in emacs of course
Necktwi has quit [Ping timeout: 244 seconds]
lumm has quit [Ping timeout: 252 seconds]
<dim>
dlowe: the SQL spec is not seriously followed by any other implementation than PostgreSQL, and the SQL spec makes no provision for data types generics the way Postgres does, which sometimes paints us in a corner and forces us not to follow it closely
<dim>
the SQL spec is a strange political game that happens between 3 proprietary vendors, what they try to achieve is having checkboxes that the other vendors haven't crossed yet so that their sales people have an edge in discussions with buyers
jprajzne has quit [Read error: Connection reset by peer]
jprajzne has joined #lisp
<dim>
that's an opinionated summary, of course, take it with some salt
robdog_ has joined #lisp
<aeth>
Even when you're using a mostly portable library you might be interested in non-portable features, e.g. JSON
<aeth>
Maybe they all have JSON support now, but probably in 5 different ways
<makomo>
emaczen: you have to use a certain SBCL-specific function to tell the SBCL internals where to find its source code
<makomo>
SB-EXT:something
<makomo>
let me check what it is
ravenousmoose has joined #lisp
ravenousmoose is now known as ravenousmoose[aw
<makomo>
emaczen: SB-EXT:SET-SBCL-SOURCE-LOCATION
gravicappa has quit [Ping timeout: 250 seconds]
robdog_ has quit [Ping timeout: 240 seconds]
<makomo>
emaczen: you usually put that in your .sbclrc to make it happen automatically when SBCL is started
ravenousmoose[aw has quit [Client Quit]
<emaczen>
makomo: Ok, let me see if I can even find my source code
<emaczen>
I think I installed via dnf (the default linux redhat package manager)
<emaczen>
I'm not even sure if I have the source code?
robdog_ has joined #lisp
<makomo>
emaczen: i don't think it comes with the package (i'm on fedora myself)
<makomo>
emaczen: i cloned it separately and pointed SBCL there
<emaczen>
makomo: I'll try something like that
jmercouris has quit [Remote host closed the connection]
<makomo>
emaczen: but i guess you should watch out that you checkout the right release (so that it matches your package manager's SBCL version), instead of the master
<emaczen>
makomo: Maybe, I'll just upgrade
robdog_ has quit [Ping timeout: 240 seconds]
Necktwi has joined #lisp
robdog_ has joined #lisp
lumm has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
Necktwi has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
ravenousmoose has joined #lisp
jerme_ has joined #lisp
scymtym has joined #lisp
warweasle has joined #lisp
karlosz has quit [Quit: karlosz]
atgreen has joined #lisp
loli has quit [Ping timeout: 272 seconds]
dgtlcmo has quit [Ping timeout: 246 seconds]
<emaczen>
when trying to install SBCL I get the error output/prefix.def: No such file or directory
<emaczen>
which comes from line 15 of the install.sh script
<dlowe>
do you have -j in your make args enviornment variable
lumm has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Necktwi has joined #lisp
q9929t has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
<Josh_2>
I made an oof so now I can't open anymore sockets because too many files open xD
ggole has quit [Quit: Leaving]
loli has joined #lisp
q9929t has quit [Client Quit]
robdog_ has quit [Ping timeout: 268 seconds]
Necktwi has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
Achylles has quit [Ping timeout: 252 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
sauvin has quit [Read error: Connection reset by peer]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
Josh_2 has joined #lisp
Nilby has joined #lisp
robdog_ has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
robdog_ has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
jfb4 has quit [Ping timeout: 246 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
orivej has joined #lisp
<emaczen>
What is the difference between sbcl-1.4.6
<emaczen>
and sbcl-1.4.16 ?
<p_l>
About 10 releases?
xkapastel has quit [Quit: Connection closed for inactivity]
<p_l>
I'd suggest reading release notes on sbcl.org
<emaczen>
p_l: How significant is 10 releases?
robdog_ has quit [Ping timeout: 240 seconds]
<p_l>
Just 1.4.16 specifies 3 incompatible changes
robdog_ has joined #lisp
<emaczen>
Why are they making incompatible changes?
<emaczen>
Those three changes look and are addmitedly minor, so why make them?
random-nick has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
<aeth>
Incompatible changes in m.n.k releases is why distros typically never update SBCL until their next distro version, months/years later, in effect creating de facto stable versions (and probably different ones for each distro)
xkapastel has joined #lisp
<aeth>
But they generally are afaik minor standards violations and the CL community takes the spec seriously
robdog_ has joined #lisp
buffergn0me has quit [Remote host closed the connection]
Necktwi has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
Necktwi has quit [Ping timeout: 250 seconds]
lumm has joined #lisp
<verisimilitude>
Those minor violations tend to be related to CLOS, from the last times I've checked.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
jkordani has quit [Read error: Connection reset by peer]
<emaczen>
I'm really surprised that I can't compile my code with SBCL 1.4.16
jkordani has joined #lisp
Necktwi has joined #lisp
lumm has quit [Ping timeout: 245 seconds]
robdog_ has joined #lisp
robdog__ has joined #lisp
<emaczen>
Is this normal?
<emaczen>
My code compiles fine with SBCL 1.4.6 and CCL
dgtlcmo has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
<scymtym>
emaczen: which error is reported?
pierpal has joined #lisp
buffergn0me has joined #lisp
<emaczen>
scymtym: My precisely it is a runtime error
Necktwi has quit [Ping timeout: 268 seconds]
<emaczen>
more precisely*
wusticality has joined #lisp
<aeth>
Generally if you can run your code in multiple implementations (e.g. SBCL and CCL) you shouldn't have trouble running it in new SBCL versions afaik.
<aeth>
If you rely on SBCL internals directly without a portability library, that's where things tend to be messy. Or, I guess, if you rely on assumptions about SBCL's implementation details of CLOS
<aeth>
Did you write specifically to SBCL?
<emaczen>
No, It looks to me that SBCL fails to run the correct typecase case
<aeth>
interesting
<emaczen>
As strange as that sounds
robdog__ has quit [Ping timeout: 250 seconds]
<scymtym>
emaczen: can you paste the code?
<emaczen>
aeth: I just built SBCL with make.sh and install.sh -- is that telling?
<aeth>
emaczen: I build SBCL from time to time and have never had issues
<emaczen>
did I build something incorrectly?
loli has quit [Ping timeout: 244 seconds]
<aeth>
emaczen: Did you install it globally over your existing SBCL?
<emaczen>
I used --prefix=/opt/
<emaczen>
Is there a possibility of strange caching that makes compilation successful on the older version?
<emaczen>
I deleted ~/.cache/common-lisp
<emaczen>
but are there others?
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
<aeth>
If you (1) rebooted, (2) didn't install *over* an older SBCL, and (3) cleared your cache, that's probably 99.9% of errors at the implementation level.
<aeth>
Well, your-side errors. It's possible you discovered a bug
<aeth>
#sbcl might be more helpful
<emaczen>
reboot the OS?
<aeth>
emaczen: never hurts
<aeth>
lots of unreproducable heisenbugs go away after a reboot
<emaczen>
I'll reboot and be right back.
emaczen has quit [Remote host closed the connection]
robdog_ has joined #lisp
<aeth>
rebooting might help if something somewhere at some level got cached to an older version for some strange reason
Necktwi has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
emaczen has joined #lisp
<aeth>
emaczen: did it work?
robdog_ has joined #lisp
<emaczen>
nope
<aeth>
emaczen: After that the only thing I can think of is to make sure you're using the correct SBCL.
<emaczen>
This is SBCL 1.4.16, an implementation of ANSI Common Lisp. from *inferior-lisp*
<scymtym>
emaczen: if you paste the code, somebody else can verify that it does not compile in SBCL 1.4.16
<emaczen>
scymtym: I have too many dependencies
<emaczen>
of my own
loli has joined #lisp
Necktwi has quit [Ping timeout: 244 seconds]
<scymtym>
but you pinpointed a TYPECASE that does not compile?
<scymtym>
or rather gets miscompiled
robdog_ has quit [Ping timeout: 250 seconds]
<emaczen>
yes
robdog_ has joined #lisp
<scymtym>
can you paste that part of the code? maybe it can be reduced to demonstrate the problem without depending on the rest of your code
<emaczen>
the typecase fails a case that it says it succeeds when I evaluate it manually
<emaczen>
sure
ravenousmoose has quit [Quit: Taking a quick nap...ZZzzz]
ravenousmoose has joined #lisp
ravenousmoose is now known as ravenousmoose[aw
ravenousmoose[aw has quit [Client Quit]
<emaczen>
scymtym: Give me a few mintues to provide a good example
robdog_ has quit [Ping timeout: 240 seconds]
<scymtym>
emaczen: sure, thanks. i'll ride home in the meantime
<aeth>
emaczen: one thing you could try doing is compiling an SBCL half way between the current version and your last-working version, and continue doing a binary search until it breaks
<verisimilitude>
Now I'm interested; this is an issue with CL:TYPECASE, emaczen?
<emaczen>
verisimilitude: Yes
<verisimilitude>
If I were you, I'd check my use with the relevant parts of the standard and, if I'm using it correctly, cease caring.
<emaczen>
verisimilitude: Yeah, I'm going to try what aeth said, and download and try other newer versions than 1.4.6
<dxtr>
How do I iterate over a list and keep the state?
<dxtr>
I'd like to keep the previous and current items
<dxtr>
or the previous and current item rather
robdog__ has joined #lisp
libertyprime has joined #lisp
<dxtr>
If I have to construct a separate list for it first then that's fine - but is there a suitable function for that?
robdog_ has quit [Ping timeout: 250 seconds]
<pillton>
dxtr: (loop for (a b) on (list 1 2 3 4 5) until (null b) do (print (list a b)))
<dxtr>
My idea was to avoid loop but I'll take it
<actuallybatman>
dxtr: I would do: `for i from 0 to (-1 (length list))` instead of `for elt in list` and offset the pointer as needed. maybe do a macro that captures prev and next per iteration to hide the loop details.
<verisimilitude>
(prog (previous current (next list)) :begin
<verisimilitude>
(setf previous current current (car next) next (cdr next))
<verisimilitude>
...
<verisimilitude>
(go :begin))
<tempate>
on a different note, is it possible to change where a cons should point to in a list? That is, can I make the second element point to the fourth, removing therefore the third from the list?
LiamH has quit [Quit: Leaving.]
<verisimilitude>
Yes, tempate; there are RPLACA and RPLACD functions for this, although you'll usually want to use (SETF CAR) and (SETF CDR).
<tempate>
pjb: thank you too, but that's hard to follow
<pjb>
tempate: ignore the functions and variables. Concentrate on the body.
<pjb>
(the dolist form).
robdog_ has quit [Ping timeout: 240 seconds]
<pjb>
tempate: otherwise, it does exactly the same as yours, how can you say it's hard to follow?
<pjb>
tempate: do you have problems with the concept of function call?
<tempate>
pjb: I don't believe I do
Josh_2 has quit [Remote host closed the connection]
<tempate>
pjb: I'm not familiar with labels, though
xantoz has joined #lisp
<LdBeth>
labels is just what u use to create local recursive functions
<makomo>
tempate: it's like FLET, except it allow recursion and one function referencing another
<makomo>
allows*
xantoz has quit [Read error: Connection reset by peer]
<LdBeth>
It’s a functional paradigm
izh_ has left #lisp [#lisp]
xantoz has joined #lisp
robdog__ has quit [Ping timeout: 240 seconds]
CCDelivery has quit [Ping timeout: 240 seconds]
<tempate>
I'm not following
robdog_ has joined #lisp
atgreen has quit [Ping timeout: 250 seconds]
<pjb>
write functions, use functions.
<LdBeth>
Well, try to stay with what it does rather than how it does
<aeth>
prog and go instead of labels? something something lambda the ultimate something something
<pjb>
tempate: so the micro-optimization here is to choose between two local variable and a list, knowing that sometimes you will just throw away the list (ie. when the run length is 1).
robdog_ has quit [Ping timeout: 250 seconds]
<pjb>
tempate: also, since having a list is so important here, I would avoid `(1 ,i) and use instead (list 1 i). (actually I would use (setf run-length 1 item i)
lumm has joined #lisp
loli has quit [Ping timeout: 245 seconds]
<tempate>
hmm, I see
<tempate>
I don't see what (setf run-length 1 item i) is supposed to achieve though
actuallybatman has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]