<beach>
nullx002: What is the reason for your question? I am asking because you seem to be new here. I don't recognize your nick.
<nullx002>
yes, using bit of lisp and emacslisp for few years, but nothing special. was off the grid for 3 years..
<beach>
I see.
jprajzne has quit [Ping timeout: 265 seconds]
<nullx002>
still only on a mobile device..
<ecraven>
quite a few lisps (in the generic sense) run on mobile devices
<nullx002>
thinking of running tiny webserver from mobile, just for..
gitgood has quit [Remote host closed the connection]
<nullx002>
use Emacs without X on emulator... clisp works well with Emacs plugins as IDE
<Nilby>
my phone can run my whole lisp mini-ecosystem just fine
gitgood has joined #lisp
<nullx002>
Nilby, yes, I use golang too... just learning
<nullx002>
emacs without X on emulator is really fast...
<nullx002>
have to git more often though for webapps
<nullx002>
and tinyscheme too... :)
narimiran has quit [Ping timeout: 240 seconds]
landakram has quit [Ping timeout: 260 seconds]
domovod has joined #lisp
imode has quit [Ping timeout: 240 seconds]
casual_friday has joined #lisp
jprajzne has joined #lisp
surabax has joined #lisp
rogersm has joined #lisp
<pyc>
how can I get the "CL-USER>" prompt that I see in most documentations. If I run CLISP I get only "[1]>" prompt and SBCL gives me "*" prompt. Where does "CL-USER>" come from?
<beach>
You use SLIME.
<pyc>
beach: and for SLIME, we use Emacs, right?
<beach>
Yes.
<pyc>
thanks
<beach>
Pleasure.
<beach>
pyc: Unless you use something like SLIME, programming in Common Lisp is going to be very painful, and you will be disgusted and abandon it.
<drbluefall>
There *is* also SLY, if you want a second option.
<beach>
Hence "something like".
<pyc>
beach: why is that? I have been writing standalone .lisp files and executing them as "clisp foo.lisp". Seems to work just fine. Not much different from Python or C.
<beach>
I am glad you are not disgusted. I would be.
<drbluefall>
Having a CL REPL at hand in your editor is very handy.
<beach>
pyc: But you are then missing out on pretty much all the advantages of Common Lisp.
<pyc>
beach: can you explain why you would be disgusted? Maybe as a beginner I don't realize why my way of doing Lisp is suboptimal.
<beach>
I guess if you are used to inferior programming languages, you don't know what you are missing.
<pyc>
drbluefall: Which one is more popular between SLIME and SLY? And for what reasons would one recommend SLY over SLIME or vice versa?
<pyc>
beach: can you cite one or two examples or features that elaborates what I am missing.
<drbluefall>
SLIME is more popular, but I mostly use SLY myself.
<pyc>
drbluefall: why do you use SLY? does it offer you something nice that SLIME doesn't?
<drbluefall>
As for which to use... it's personal preference, really.
<beach>
pyc: In Common Lisp, you develop code interactively, one definition at a time. You often compile top-level forms immediately after you type them.
<beach>
pyc: You get function signatures displayed in the minibuffer as you type.
<drbluefall>
I've just found that SLY feels at least a little nicer to use than SLIME
<beach>
pyc: You often switch between the code and the REPL to test a single function after you typed it.
<carkh>
also completion, and most importantly, the debugger
<pyc>
beach: thanks! I will stick to SLIME then. I tried SLIME once briefly but did not know enough to be able to realize its usefulness.
<beach>
pyc: You get help with backtraces and such.
<beach>
pyc: You hit a single keystroke and you get the source code of a stack frame.
<beach>
pyc: I could go on, but I think that's enough to get you started.
<Nilby>
pyc: In CLisp you can set the prompt with the custom:*prompt-.. variables, e.g. (setf custom:*prompt-start* "foo")
<pyc>
beach: yes, thanks. that is convincing enough. i will stick with SLIME and learn it more.
<beach>
Great! Good luck!
<drbluefall>
o7
<drbluefall>
godspeed.
X-Scale` has joined #lisp
<carkh>
though i take exception at this "inferior language" business. a tool for each task.
<drbluefall>
^
<drbluefall>
All PLs have their purpose
<beach>
That just isn't true.
kevingal has joined #lisp
<carkh>
except cobol =)
<drbluefall>
Oh yea that.
<carkh>
this isn't true actually
<beach>
Well, I guess it sort of is, if you count realizing a wet dream by an incompetent hacker without training.
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
<beach>
Oh, and convincing incompetent management about what programmers to hire, and what language to use for the next project.
<carkh>
i remember reading a blog post about some company that couldn't get out of cobol because of its outstanding decimal numbers processing
<carkh>
so even cobol has its place it seems
<drbluefall>
Like, say when it comes to web, I will be the first to admit that I will sooner reach for Rust
<drbluefall>
because actix-web
<beach>
That's not a purpose of Rust. It is a tool that happens to be available.
<beach>
I will stop now. This kind of discussion makes me upset.
<drbluefall>
k
<carkh>
yes, i think i'll stick to clojure for the web, rust is annoyingly low level for that kind of stuff
<carkh>
CL is a happy middle ground
<drbluefall>
fair
<drbluefall>
Perhaps it's just a case of experience.
<carkh>
that borrow checker gymnastic seemed annoying to me. Though i can see how this is all usefull for low level work
<drbluefall>
For me, the draw was more the ecosystem than the language itself (although the language felt much nicer than what I was using before).
<carkh>
yes the ecosystem is awesome
<drbluefall>
In contrast, I came to CL purely for the language
<drbluefall>
since it just feels *so nice to write*
<carkh>
that's one thing missing here, a competent packge system (even if quicklisp is a big step in the right direction)
wxie has quit [Ping timeout: 246 seconds]
<drbluefall>
quicklisp I find usually sufficient, although something akin to cargo would be absolutely *amazing*
<moon-child>
imo nothing beats perl/cpan for package management. But quicklisp is fine
<drbluefall>
I've never used perl/cpan, so I can't make a judgement on it myself
<drbluefall>
I think the most painful experience with packages and dependencies was in C/C++.
<carkh>
ah yes, and the build system jungle ><
<Nilby>
What do you folks find missing from quicklisp that is in cargo?
<moon-child>
the main essential complexity with c is that they tried to make dynamic linking work. Dynamic linking is a really nice idea, but it's proven itself to be unworkable
<carkh>
nilby : per project library version pinning
<drbluefall>
^
<carkh>
it's not silver bullet, but it helps
<Nilby>
Ah, I see.
<carkh>
right now, any updating of your libraries is an adventure
<carkh>
what will it break ?
<beach>
moon-child: Dynamic linking was the norm in Multics and it worked great. The problem you see are very likely due to the fact that Unix imposes a programming model that makes the process look like the naked machines from 70 years ago or so.
<Nilby>
I might be wierd, but I very rarely have any library version trouble with CL.
<beach>
moon-child: We certainly knew how to do it better half a century ago.
<moon-child>
beach: sure
<moon-child>
beach: I think implicit in 'c' is 'c+unix'
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<moon-child>
(or windows, which is close enough where it counts)
<beach>
I see (I "C"?).
<drbluefall>
I c.
<beach>
moon-child: Yes, Windows is essentially the same.
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<beach>
I was horrified when I learned about Unix-style dynamic linking in the book "Linkers and Loaders" by John Levine.
<jdz>
Nilby: That is not very weird if the language supports optional and named parameters.
<beach>
marcoxa: Yes, that multics. And the `@' convention is not used on IRC.
<Nilby>
jdz: Exactly!
<jdz>
Nilby: And also multiple return values. That way code is much easier to update without breaking existing users.
<kevingal>
I miss virtual environments from Python, though I guess that's not something that's missing from quicklisp.
<beach>
marcoxa: Unix was meant to mimic as many features as they could from Multics, but on a very small PDP machine at the time. I guess they managed to use `ls' and a few more things.
<Nilby>
jdz: With those things, it seems almost trivial not to break compatibility.
Stanley00 has quit []
<beach>
I am not in favor of a return to Multics, because it had similar (but not as severe) address-space limitations as 16 or 32-bit machines do. But we can do better now.
<drbluefall>
Admittedly I'm not entirely familiar with Multics, since it seems to be entirely before my time
<beach>
By the way, the Common Lisp condition system was largely inspired by that of Multics PL/I. All other languages seem to have forgotten about that.
<beach>
So the exception-handling of most languages is indeed inferior to that of Common Lisp and Multics PL/I.
<beach>
drbluefall: Lame excuse. It is important to know computing history.
<beach>
Or else, you will think that what we have now is the greatest thing since sliced bread.
<drbluefall>
I'm *barely a year out of high school.*
<drbluefall>
bite me.
<beach>
That's a good excuse though. Not the previous one.
<beach>
Like "I haven't yet had the time to read up on computing history" is acceptable.
<beach>
But "Since it is before I was borne, I don't care about it" is not.
<beach>
*born
<drbluefall>
I intend to double down on CL and Rust, since both appeal to me in their own ways enough that I want to invest time in both
<carkh>
can't be an expert on everything
<beach>
carkh: I said nothing about being an "expert". But it is important to know what we had and that was lost in favor of the truly inferior stuff we are forced to use today.
<moon-child>
drbluefall: rust is mostly ocaml and c++, with bits of cyclone and clean mixed in. Not worth the effort. If you want to learn about the interesting things in rust, I recommend ocaml and ats
<kevingal>
Are you even a programmer if you haven't mastered COBOL, FORTRAN, and FLOW-MATIC?
<carkh>
beach: i think it might depend on your goals, i can see how you may be interested, due to your endeavours
<beach>
carkh: Oh, it definitely depend on your goals. Like if all you want is to make money by doing what everyone else does while being ignorant of what we could have, then sure, just use the tools you need.
<drbluefall>
moon-child: I think something being "worth the effort" is a subjective matter
<beach>
carkh: Luckily, I find that Common Lisp programmers often want more than that, and that's why I like to hang out here in #lisp.
<drbluefall>
Like, other languages may have features that Rust also has, but it ain't just the features of a language that matter. It's also the experience developing in it
<Nilby>
Now I can have exception handling unix and even other OSes thanks to CL.
<carkh>
beach ; right i think noone in this channel is ignoring the past
<jackdaniel>
are we talking about cl vs the world again? :)
<beach>
That would be good if it were true. And, in the meantime, let's educate the others.
<carkh>
beach: hum didn't mean to upset you, i i did i apologise
<carkh>
if*
nullx002 has quit [Quit: qicr for android: faster and better]
<kevingal>
It refers to an Altair emulator that lets you enter a program using virtual switches.
<jackdaniel>
I've wanted to learn rust some time ago, but my "Hello world" program still compiles ;)
<drbluefall>
well, while y'all do that, I'm gonna get cracking on with my web api.
<drbluefall>
Take care!
<jackdaniel>
\o
drbluefall has quit [Quit: peace]
drbluefall has joined #lisp
kevingal_ has joined #lisp
attila_lendvai_ has quit [Ping timeout: 272 seconds]
Alfr has joined #lisp
h4ck3r9696 has left #lisp [#lisp]
Keyboard1orrier has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<pyc>
Is there a nice channel that focusses on the retro and historical aspect of computing?
<beach>
carkh: No, no. I upset myself by getting into these discussions.
<marcoxa>
beach, OT, but I presume you know about Hercules, SIMH and OS2200 Express :)
<beach>
Not very much, no.
contrapunctus has joined #lisp
<marcoxa>
I wasted a lot of ti.... er, had a loto of fun with those the past year. Hey. I learned JCL :)
<beach>
So, according to Land of Lisp, page 40, if you type (cons 'pork (cons 'beef (cons 'chicken ()))) to the REPL, it would be "perfectly correct" for the REPL to answer (cons 'pork (cons 'beef (cons 'chicken ()))) in addition to (pork beef chicken).
<beach>
Reading badly written books is another way of making me upset.
<beach>
marcoxa: I can imagine.
<beach>
s/in addition to/instead of/
<marcoxa>
beach: as I said, it has been fun. I also veered off a tangent and wrote the missing JCL mode for Emacs :)
<beach>
Oh, that sounds like real fun.
<marcoxa>
PS I agree on PL/I error handling et similia.
<kevingal_>
What's JCL?
<beach>
I won't elaborate, for fear of being reprimanded by jackdaniel again.
<jackdaniel>
I'm not reprimending anyone, I was just curious if we've reached this point of the year when this discussion theme starts another cycle!
<beach>
jackdaniel: I am just giving you a hard time.
<jackdaniel>
like, erm, eternal late february :)
frgo has quit [Remote host closed the connection]
<beach>
Maybe there *is* a cycle. Could be the full moon, maybe?
frgo has joined #lisp
<beach>
Anyway, back to register allocation.
<jackdaniel>
who would have thought, that a simple method resize-sheet could be this tricky
<jackdaniel>
(if we insist on doing the right thing with arbitrary sheet regions :)
<Nilby>
heh, They haven't got it right in web browsers yet either
<kevingal_>
Looks really fun, marcoxa.
<Nilby>
resizing is one of those potentially hard constraint problems
<jackdaniel>
well, it is not that hard in this case
<jackdaniel>
still tricky!
<kevingal_>
Are you planning to get a job programming mainframes? The thought crossed my mind when I read those articles about the lack of COBOL programmers.
<marcoxa>
kevingal it has been fun. I also learned a lot about Emacs that I did not know.
gzj has joined #lisp
<marcoxa>
Let's say that I am in the right age group to apply for a COBOL programmer position :) I do have other plans though :)
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
<kevingal_>
I had a little daydream about walking through air-conditioned halls and learning the secrets of the mainframes from the ancient sages. But maybe I'll try out this emulator instead, haha.
<rogersm>
folks, any recommendation on changing Common Lisp colouring in emacs? After some time using the standard emacs colours I would like to try something different.
akoana has joined #lisp
<ck_>
sounds like a question custom-crafted for #emacs ? but try M-x customize-themes
euandreh has quit [Ping timeout: 258 seconds]
Sheilong has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
GZJ0X_ has joined #lisp
euandreh has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
lotuseater has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
jeosol has quit [Quit: Connection closed]
sxmx has quit [Quit: WeeChat 3.0.1]
nicktick has joined #lisp
narimiran has joined #lisp
zacts has joined #lisp
sxmx has joined #lisp
<marcoxa>
kevingal I can be your guide, but only to point out the dangers, not to fight them :) Plus, you will need a button down shirt (white), thick rimmed glasses, a skinny tie and, above all, some pens in your shirt pockets. Dilbert is an amateur.
<jmercouris>
when doing CFFI, is there anything I can realistically do in the ldb?
<jmercouris>
backtrace just reveals: 0: Foreign function gsignal, pc = 0x7fbf3cdcf08a, fp = 0x7fbf19cf7778
<jmercouris>
that's literally it
<jackdaniel>
you may attach gdb to the running process and examine these addresses
<jmercouris>
hm, I see
<jmercouris>
that may be a good idea
nullx002 has quit [Client Quit]
jonatack_ has joined #lisp
nullx002_ has joined #lisp
<marcoxa>
Bye for now...
marcoxa has quit [Quit: ERC (IRC client for Emacs 27.1)]
<jackdaniel>
see you \o
<nullx002_>
hi all,
nullx002_ has quit [Client Quit]
<jackdaniel>
I personally usually print these numbers and add put it in my "do not use cffi" archive files
<jackdaniel>
nullheroes: hey
<jackdaniel>
nullx002_ *
<jackdaniel>
s/cffi/ffi libraries/
<jmercouris>
I was really confused for a moment there
Bike has joined #lisp
jonatack_ has quit [Quit: jonatack_]
jonatack has joined #lisp
CrazyEddy has joined #lisp
galex-713 has joined #lisp
<pyc>
what is the difference between Quicklisp and Roswell? when would one use one vs. the other?
aartaka has quit [Ping timeout: 240 seconds]
<jackdaniel>
roswell is a set of C programs that is meant to help you manage local lisp installations and such
<jackdaniel>
quicklisp is a program that lets you download libraries and load them in your running image
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
nullx002 has joined #lisp
<pyc>
thanks jackdaniel
<pyc>
is it possible to have multiple parallel quicklisp installation to separate the dependencies of one project from another?
<jackdaniel>
yes
<pyc>
how can I do that, I see quicklisp always comes and installs itself at ~/quicklisp
<jackdaniel>
I think that the funciton quicklisp-quickstart:install has a keyword argument that allows you to specify the path
attila_lendvai has joined #lisp
<pyc>
jackdaniel: excellent! thanks for the help.
<jackdaniel>
sure
<nullx002>
i used sbcl now on ecl.... anything different?
<jackdaniel>
nullx002: ?
gzj has quit [Remote host closed the connection]
<nullx002>
termux only has ecl coz of clang...
<nullx002>
no sbcl
GZJ0X_ has quit [Ping timeout: 240 seconds]
<jackdaniel>
nullx002: but what is your question?
<Nilby>
nullx002: There's a gcc for termux, and I think someone compiled an sbcl using it.
<pyc>
here is one thing that confuses me. I want to keep a list of words in my program and I will iterate on those words and do stuff. Those words could be IDs of some table entries or lookup keys or anything else. Should I define them as (defvar *keys* '("title", "tag", "author", "date")) or should I do (defvar *keys* '(title, tag, author, date))?
<jackdaniel>
you don't put commas between arguments in common lisp
<Nilby>
pyc: Probably the second way, without the commas
<Xach>
beach: i really enjoy the style guide in the SICL repo
<beach>
Thanks!
<pyc>
jackdaniel: sorry about the commas. muscle memory from other languages.
<pyc>
Nilby: why is the second way preferred?
<Nilby>
Symbols usually can be compared faster than strings.
skapata has joined #lisp
<Xach>
beach: the tex source code is quite easy to read, but it would be a bit easier if rendered. is there a PDF or other rendered version available?
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<beach>
Xach: Is this the document in SICL/Specification/...?
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<Xach>
Thank you
kaiwulf has joined #lisp
<beach>
Pleasure.
waleee-cl has joined #lisp
Inline has joined #lisp
euandreh has quit [Quit: WeeChat 3.0.1]
euandreh has joined #lisp
<Xach>
beach: I like your point about grammatical vs. idiomatic. Do you view idiomatic as implying a unique result? Is it improper to say that there are multiple idiomatic solutions for a given problem?
<Xach>
One challenge of establishing style seems to me to be choosing between multiple arguably-valid choices, and I'm not sure that those choices are appropriately labeled "idiomatic"
toorevitimirp has quit [Read error: Connection reset by peer]
sjl has joined #lisp
<beach>
I believe that there could be multiple idiomatic solutions. But I can't think of any such cases right now.
<beach>
And, sure, there are often several choices possible, and it may be that there is no particular idiom for the situation in question.
<Xach>
Hmm. I am thinking about resolving differences like preferring to use keywords for LOOP grammar vs. not, where the result really seems to be a matter of the weight given to each advantage and disadvantage.
<Xach>
and the weight is often quite personally felt
<beach>
Yes, in this case, I have no particular opinion myself, other than that I choose one over the other. I won't reject code written in the other style.
<Xach>
Your examples illustrate well the obviousness of how some grammatically valid things are just obviously wrong to a native speaker
<Xach>
But some things are not obviously wrong or right
<beach>
Indeed.
<Xach>
beach: Not even in the name of consistency?
<jackdaniel>
DO crowd churns in and says: don't LOOP with LOOP, DO DO with DO :)
<beach>
Xach: Let me put it this way. If I write a book myself, I would use consistent choices in the entire book. But if I am the editor of a book where different authors are in charge of different chapters, I find it normal that the choices can be different in different chapters.
<beach>
The same goes for SICL code.
<Xach>
beach: Interesting! What if you are at a company and every area of the code may have many different authors over different time periods?
<beach>
If a "module" is written by someone other than me, it is normal that this code looks slightly different from mine in situations where no particular idiom is called for.
<Xach>
(I think the SICL endeavor is not too different from that)
<Xach>
There is also the issue of "what should a new author do?" where they may not have established preferences to impose
<Xach>
New as in newbie
<jmercouris>
I think as long as the code is cleaer, and each module has a clear API boundary, it can be in whatever style it wants
<Nilby>
I think there certainly a parallel between code and natural language writing style and style guides.
<jmercouris>
Except that I don't think writing and reading code is like writing and reading books
<jmercouris>
I think of it as a higher level activity than natural language
<beach>
Xach: Again, I think there are "idioms" that should always be followed, and "personal differences" that can in fact be interesting, in that you can see who wrote a particular module. Within a module, it is preferable to keep a single style I would say.
<jmercouris>
you're right though, there are some parallels
<jmercouris>
like don't write super long paragraphs
<beach>
jmercouris: I won't accept contributed modules for SICL with any style that does not follow what I consider idiomatic Common Lisp.
<jmercouris>
beach: that makes sense, you are after all the capitane!
<jmercouris>
I am a believer in VERY CLEAR, very good API
<jmercouris>
beyond that, it does not matter to me, it can always be rewritten
<jmercouris>
in fact, it probably will be rewritten
<jmercouris>
now, if you have leaky abstractions, lots of shared state, or a bad API, this approach is not feasiible
<beach>
Xach: There is another chapter, chapter 32, that is more detailed and perhaps more for newbies and more for SICL. I wrote chapter 31 to be more general.
<beach>
Both chapters are unfinished, though, so I may add more things later.
<Nilby>
You can have two excellent authors with quite different but good styles, but the average person's style might be pretty bad and could use to closely follow guides.
<jmercouris>
Nilby: indeed
<jmercouris>
that's why I only like to work with people commited to becoming excellent
terpri has joined #lisp
<beach>
Xach: I am not sure I addressed your issues.
aartaka has joined #lisp
<beach>
jmercouris: Natural languages and programming languages do have a lot in common though, like the language-specific idioms I wrote about in chapter 31. And also something that most programmers who have never worked in a team seem to ignore, namely that both are meant primarily as a means of communication between people.
<jmercouris>
I would argue that programming languages are primarily a means of communication between an individual and a machine
<beach>
jmercouris: You don't have to look very far back in the #lisp logs to see opinions in that direction.
<jmercouris>
however, when working in a group setting, it becomes the lingua franca
<jmercouris>
it is not that they are /meant/ to be for communication with other people
<jmercouris>
they are however the only effective means of such communication
<beach>
jmercouris: The entire body if software-engineering literature disagrees with you.
<jmercouris>
well, OK :-)
<jmercouris>
we could all use engineering diagrams, which /ARE/ meant for communication of such ideas
<jmercouris>
but frankly, nobody understands them :-D
<jmercouris>
whereas we all understand the language we are programming in, hence why we use it to convey these ideas precisely
<jmercouris>
I will note that most pseudocode examples are just that, a pseudo language designed to mimic programming languages for the purpose of conveying information amongst programmers
ljavorsk has quit [Ping timeout: 240 seconds]
<jmercouris>
the key difference here is that these set of programmers do not share a lingua franca!
<jmercouris>
hence the invention of the pseudo language
<beach>
jmercouris: Look, let me say this again for the nth time: I am not smart enough and not knowledgeable enough to make up my own ideas about programming, so I rely on established literature, smart, knowledgeable, and experienced people who have already done it, and who mainly agree with one another.
<jmercouris>
I'm not sure where I'm going with this other than to say that I think programming langauges are to make it easier for the programmer to communicate with the computer, not with each other
<jmercouris>
beach: I understand the appeal you are making, but I have a lot of ideas that disagree with people much smarter than me
<jmercouris>
sometimes even experts are wrong :-)
<jmercouris>
and I am not so far out of my domain that I can't have an opinion
<jmercouris>
I'm not exactly arguing astrophysics here, I am in fact a computer scientist
<beach>
jmercouris: The programmers who don't share the same ideas about grammatical vs idiomatic phrases with these smart, knowledgeable, and experienced people i am referring to, are precisely the programmers who write code that will waste a lot of time to the maintainers.
<jmercouris>
ay yai yai :-D
<jmercouris>
I hope my code isn't too dirty :-D
<Xach>
beach: To some degree. I think there's an interesting difference between volunteers, students, and employees when it comes to contributing to a shared code base.
<beach>
Xach: Sure, the differences exist. But they are not always desirable.
<Nilby>
If you are primarily communicating with the machine, you could just write assembly, like the lovely 124 line PDP-1 Lisp GC in assmebly.
<Xach>
beach: I'm thinking specifically about how an employee will do something they slightly disagree with because they are paid, and students might do it because someone in authority seems to know better, but volunteers can be more likely to simply stop volunteering.
<Xach>
And how that applies to issues of taste and preference
<jmercouris>
Nilby: you will have a hard time communicating with the machine, in my opinion programming languages are an attempt to make machine language closer to our language, so we can talk to them more easily
<beach>
jmercouris: And let me also say this for the nth time: If you keep your code to yourself, as far as I am concerned, you can use whatever style you want, following whatever personal ideas you like, but if you expose your code for others to read, like if you ask for help, it is very impolite not to follow these idioms.
<jmercouris>
beach: nobody is perfect, I do my best :-)
ldbeth has joined #lisp
<beach>
jmercouris: Well, the way it should work then, is that when you submit code that violates these idioms, and this is politely pointed out to you, the right answer is to fix your code, and not argue that you can do whatever you please.
charles` has joined #lisp
<beach>
Xach: Sure, difficult issues. Especially since the authority (employer, teacher) may not be knowledgeable enough to know the difference between grammatical and idiomatic phrases either. In fact, that's probably rather the rule than the exception.
<jmercouris>
beach: Hm, I don't remember doing that
<beach>
jmercouris: I meant the third-person "you" here.
<jmercouris>
I see
<beach>
Not you personally.
<beach>
But again, you don't have to look far back in the logs to see that kind of behavior.
<jmercouris>
I think that's pretty far
<jmercouris>
s/far/fair
<beach>
"But *I* prefer ...."
<beach>
"Please look at my code and give me help, even though I don't give a damn about respecting the rules that will make it easy for you to understand my code, so please spend 10 times as much time as you should have, just because *I* don't care."
<jmercouris>
hm, yeah
<jmercouris>
it's quite common this
<beach>
Very.
<jmercouris>
I notice it a lot in pull requests
<Xach>
"i have to get this done for an assignment and after that i will never use lisp again"
<jmercouris>
very convoluted code, very strange designs :-D
<jmercouris>
I can't exactly blame those people, for them, Lisp is just a stepping stone
<beach>
Xach: Yes, that too.
<jmercouris>
they don't care about it
<beach>
jmercouris: But then, we don't care about them.
<jmercouris>
yes, but that might make them a bit salty :-)
<jmercouris>
and I am wondering how to make it like flet to allow the declaration of several functions
<jmercouris>
how could I make it allow for multiple functions
<beach>
As we recently discussed (me and ebrasca) in #sicl, the reason many programmers don't know the distinction between grammatical and idiomatic phrases is that they do not read other people's code.
<beach>
And our teaching programs do not require them to do so.
<jmercouris>
that's true, I ready very little code outside of algorithmic snippets in my studies
<beach>
So how can they tell the difference? It would be like a novel writer who never read books by other authors.
<beach>
I for one would very likely not appreciate a novel by such an author, much like I don't appreciate the code of someone who has not figured out the idioms.
attila_lendvai has quit [Ping timeout: 272 seconds]
<beach>
Again, like I said in #sicl, my (admittedly small) family studied English literature at the university, and they had to read a novel per week as homework assignment.
<jmercouris>
seems excessive, a novel per week
<jackdaniel>
people who do not study often read in this pace (if they have 1h a day for that), doesn't seem excessive to me
<ldbeth>
I just find that sometimes I'm mimicking idoms from other programming languages when I'm rewriting CL
<ldbeth>
*idioms
<jackdaniel>
who do not study literature*
<beach>
ldbeth: And that's particularly bad, as I clearly write in chapter 31.
<Xach>
ldbeth: that's an accent
<Xach>
accent is not the right word...
<lukego>
Hey I want four variables bound to fresh hashtables but I'm not willing to spend four lines of code on let clauses. What's a less crappy solution than this? (destructuring-bind (left right top bottom) (mapcar #'make-hash-table (iota 4))
<beach>
Yes, very similar to an accent in natural language.
<Xach>
but using idiomatic "foreign" phrases with literal translation is a good recipe for confusion
<lukego>
(oh duh this is broken anyway, the arg..)
<beach>
Xach: I used "accent" when I explained this phenomenon to my students. It's a fine use of the word.
<Xach>
beach: I think of accent as more phonetic than grammatical, I suppose.
<ldbeth>
ah, thank you
<beach>
Yes, but I couldn't find a better term.
<jackdaniel>
lukego: 4 lines of let sounds much better than dbind
<lukego>
jackdaniel: yeah so what's the fantastic third option that we're not talking about? some great macro in serapeum or something?
<jackdaniel>
if it would be 30 hash tables, I'd write a macro
<jackdaniel>
if it is four, I would use let
<Xach>
jackdaniel: being monolingual, i can't think of specific examples off the top of my head :(
<Xach>
jackdaniel: but locally, if the roads are very icy, someone would clearly understand me if i told them "it's just like a bottle outside" - and i don't think that would carry the same meaning if literally translated.
<Xach>
i suppose the term is idiom, but in a slightly different sense that we have discussed so far
<jackdaniel>
sounds like a regionalism (or a dialect)
<beach>
Yes, "idiom" has two different meanings.
<ldbeth>
but why there's 4~30 hashtables
villanella has quit [Ping timeout: 240 seconds]
<ldbeth>
maybe it is possible to avoid so much duplications
<lukego>
(Speaking of "accents" I'm basically trying to write (1 to: 4) collect: [ Hashtable new] but in Lisp rather than Smalltalk)
<lukego>
well, no, that would be a list. oh well I'll stop trying to be cute
<ldbeth>
com'on, many of us get used to other languages
<lukego>
jackdaniel: maybe I can replace it with one hashtable and a compound key e.g. cons
<ldbeth>
or an array based struct
<lukego>
or a hashtable of 4-vectors...
<Xach>
fourples, please.
<ldbeth>
omg
<jackdaniel>
I think that by now you'd be able to type all four bindings by hand!
orivej has joined #lisp
<lukego>
jackdaniel: yeah. well I already wrote them out by hand, but now I'm rewriting this file for clarity because it got too confusing, and I'm not wild about writing them four times by hand twice :)
<jackdaniel>
by now you should be able to write them twice by hand twice (that is 16 times!)
<ldbeth>
"Consider the use of locks to be free. We predict that a technique call 'speculative lock elision' will soon be available in all main processors."
<ldbeth>
well thats great
<jasom>
I think Itanium had that with TSX?
attila_lendvai has joined #lisp
<jasom>
And it was actually slower than non-speculative if there was a conflict (and conflicts included system calls and interrupts)
judson_ has joined #lisp
Sheilong has quit [Quit: Connection closed for inactivity]
pfdietz has joined #lisp
<beach>
I may have to modify that phase.
<ldbeth>
Is it possible to "deriving" a lexer from readtable
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
<ldbeth>
or how is fault tolerant lisp code parsing supposed to be done?
<beach>
What kind of fault tolerance are you referring to?
<lukego>
and behold! my cleverly refactored version of the program is incomprehensible and the unrefactoring commenceth
<jackdaniel>
it is very impossible to "parse" common lisp code; it is usually read
<jackdaniel>
(you may have a customized reader)
galex-713 has joined #lisp
<jackdaniel>
s/very impossible/very hard/
<ldbeth>
parsing when paren pairs are unmatched/some read macros are undefined
gioyik has joined #lisp
<beach>
ldbeth: You use Eclector and handle the conditions it signals.
<pfdietz>
A readtable can reference arbitrary code and cause arbitrary computation.
<ldbeth>
I remember there's a proposal for "sandboxing" computation effects?
<ldbeth>
beach: ah, conditions! and of course I can continue reading from the condition handler in CL
<beach>
ldbeth: I use sandboxing on a daily basis. SICL code is executed in a first-class global environment represented inside a host Common Lisp implementation.
aeth has quit [Ping timeout: 240 seconds]
ldbeth has quit [Remote host closed the connection]
ldbeth has joined #lisp
aeth has joined #lisp
aartaka has joined #lisp
* ldbeth
try setting up sicl right now
<beach>
I don't think that's enough for you to use sandboxing independently, though.
<beach>
I haven't set things up (yet) to make that easy to do.
<lukego>
Hey what's a neat way to do some final tests on a functions' return value? like I have (calc-foo) and I want (let ((foo (calc-foo))) (check-foo foo) foo) but less verbosely? just do (check-foo (calc-foo)) and make check-foo return the value too? or is there a "prog1" type mechanism that I'm overlooking?
<pyc>
I am creating some data records hard-coded in the source code. I have to ways to define each record: (1) (list :name "alice" :age 30 :city "london") (2) '(:name "alice" :age 30 :city "london"). Which one is preferred? Are there are any best practices or pros/cons around it?
<Bike>
if the records are mutable, do not use quotation. that's probably the main thing.
<Bike>
lukego: no, that's pretty much it. that's why a lot of for-effect functions in the standard return their argument, like initialize-instance
<beach>
pyc: What Bike said, but also, I would not use lists for stuff like that. I would use standard objects instead.
<lukego>
Bike: okay cool works for me, just a bit rusty and wondered if that was more of a Smalltalk'ism than a Lisp'ism.
<jmercouris>
Not sure why it results in a warning...
<lukego>
Hey - me again - what's the significance of SLIME coloring "check-" functions in a different font-lock color?
<pyc>
beach: You man objects from CLOS? I haven't learnt that yet. Let me look up a tutorial.
eoyath has joined #lisp
<Bike>
lukego: i think the idea is that check- is an error checking thing.
* ldbeth
try not scare off people by asking them using clos
Lord_of_Life has quit [Ping timeout: 240 seconds]
<lukego>
Bike: okay. So since my function is basically being called for the side effect of signalling an error or not then I guess I should embrace this and keep check- in the name
<beach>
pyc: Many people call them "CLOS objects", but in fact every Common Lisp object is the instance of some class so that term is meaningless. That's why I used the correct term "standard object" which is what you get when you instantiate a class defined by DEFCLASS.
<beach>
pyc: You can use lists for now, but what I would do then is to define specific accessors, defined in terms of FIRST, SECOND, etc. And then use the accessors in your client code.
cods has joined #lisp
cods has quit [Changing host]
warweasle has joined #lisp
<beach>
pyc: Or you can define them in terms of ASSOC if your lists are unordered.
<pyc>
beach: okay, since I am still learning I will just use lists to play with Lisp right now. It will take me a few days to learn CLOS, so I will follow your advice then.
galex-713 has quit [Ping timeout: 272 seconds]
<jmercouris>
Anyone know why this results in slightly different behavior?
<jmercouris>
anyone know what is wrong with my macro?
galex-713 has joined #lisp
<beach>
It looks like you used different current packages for the two versions.
<jmercouris>
I didn't change a thing though
<jmercouris>
I only changed the contents of the macro
domovod has quit [Ping timeout: 240 seconds]
zxcvz has joined #lisp
sauvin_ is now known as Sauvin
<jmercouris>
what the F
<jmercouris>
it doesn't change the package in Alfr 's macro
<jmercouris>
that makes zero sense
<jmercouris>
we are doing literally the same exact thing
Sheilong has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
kaiwulf has quit [Ping timeout: 260 seconds]
aeth has quit [Ping timeout: 240 seconds]
<lukego>
Couldn't resist rolling a macro (check (calc-foo) (check1-foo _) (check2-foo _)) I'm on a bad-takes roll today
<ldbeth>
why not check in the caller instead of callee
galex-713 has joined #lisp
<lukego>
mostly because when I'm hacking away at the REPL I'll often call the callee directly but still want to know if the checks fail
aeth has joined #lisp
<lukego>
which I guess is a way to say that the checks belong in the callee i.e. they say whether it is producing well-formed output (independent of the context of the caller)
long4mud has quit [Quit: WeeChat 3.0.1]
<lukego>
(this is a simple lexer that just needs to sanity-check the tokens it's returning)
<lukego>
Sorry if I've asked before but any happy users of check-it? I'm thinking about trying to use it for all of my testing, even though that seems a bit of an uphill battle, in case it forces me into some kind of a productive design-for-testability mindset. but I dunno if tears await
Noir has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
abhixec has joined #lisp
bilegeek has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
<lukego>
(Thank you all for your patience with my thinking aloud thoughts best kept to oneself kind of evening...)
<Nilby>
It's like I listened to the radio of watching a movie of you coding :)
galex-713 has joined #lisp
nullx002 has quit [Quit: ERC (IRC client for Emacs 27.1)]
galex-713_ has joined #lisp
<warweasle>
A long time ago, before the first Iraq war, there was a DARPA project that used lisp to predict fuel logistics to help with planning. Anyone know more about this?
galex-713 has quit [Ping timeout: 272 seconds]
galex-713_ has quit [Ping timeout: 246 seconds]
imode has joined #lisp
<warweasle>
I read that it saved enough money to pay for all the previous DARPA projects up until then.
orivej has quit [Ping timeout: 240 seconds]
Josh_2 has joined #lisp
<Josh_2>
afternoon
surabax has quit [Ping timeout: 260 seconds]
surabax has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
surabax has quit [Client Quit]
<warweasle>
Josh_2: Hello.
judson_ has joined #lisp
<Alfr>
jmercouris, I don't see what goes wrong in that what you've pasted, sorry.
<Josh_2>
Hows your work/projects coming along warweasle?
g3n713m4n2 has joined #lisp
<pyc>
We can make a hard-coded list of records like this: (defvar *records* '((:name "alice" :age 30) (:name "bob" :age 31))). But what if I did this: (defvar *records2* '('(:name "alice" :age 30) (:name "bob" :age 31))). Will the second one lead to any problems in practice while further programming?
<Bike>
well, it's a different list.
<pyc>
Oops, typo in above question. Let me fix it and repost.
<pyc>
We can make a hard-coded list of records like this: (defvar *records* '((:name "alice" :age 30) (:name "bob" :age 31))). But what if I did this: (defvar *records2* '('(:name "alice" :age 30) '(:name "bob" :age 31))). Will the second one lead to any problems in practice while further programming?
<Bike>
still a different list.
<Bike>
'x is short for (quote x).
<Bike>
''x = (quote (quote x)). So for example (listp 'x) => nil, but (listp ''x) => T.
<jackdaniel>
'('(:name "foo")) is a list ((quote (:name "foo"))
<jackdaniel>
probably not what you'd expect
<pyc>
Is the second one that has quoted list inside quoted list uncommon in real world Lisp programming?
<Bike>
yes.
<Bike>
Not much point in quoting it unless it's going to be evaluated.
<jackdaniel>
it is Uncommon Lisp
<pyc>
Haha!
Noir has quit [Ping timeout: 272 seconds]
<warweasle>
Josh_2: I couldn't work on it last night. Could barely move.
<pyc>
Please provide advice on proper coding style: https://plaster.tymoon.eu/view/2314 From code I have seen I think *records2* is the right style. What about the other two styles? Are they outright unacceptable?
<Josh_2>
eew
<Josh_2>
number 2 is my choice
<beach>
pyc: Yes, nobody writes code like that.
<beach>
pyc: `(' is never followed by whitespace.
<beach>
pyc: ')' is never preceded by whitespace.
<beach>
... well, *almost* never.
g3n713m4n2 has joined #lisp
<pyc>
Josh_2: beach: thanks. so my suspicion was right. I guess I have to get used to this style. I was tempted to put some whitespace to demarcate each record clearly but looks like that's not the style.
nullx002 has joined #lisp
<Alfr>
beach, #\newline and #\return are whitespace. ;)
nullx002 has quit [Client Quit]
<pyc>
It appears to me that the correct style is to treat the parentheses as invisible. As if the parentheses are just not there, so not worry about them at all.
<Josh_2>
The parens inform the reader about more than just the style
<beach>
Alfr: Exactly. And `(' is never followed by newline.
Noir has quit [Read error: Connection reset by peer]
<beach>
Alfr: And `)' is never preceded by newline.
nullx002 has joined #lisp
<beach>
pyc: Open pretty much any good book on Common Lisp and you will see that these rules are followed.
<Josh_2>
with record 2, you could just put a newline between each entry in the list
<pyc>
beach: yes, PCL follows the style you recommended
<beach>
pyc: And PAIP, and "gentle" and "ANSI Common Lisp", and, and ...
<Alfr>
beach, with these clarifications, I'm happy now. ;)
<pyc>
Josh_2: yes, but the first record is still attached to the opening '(. I was trying to demarcate that too but looks like that is not a good idea as per coding style.
galex-713 has quit [Ping timeout: 272 seconds]
<nullx002>
..
nullx002 has quit [Client Quit]
nullx002 has joined #lisp
<pyc>
beach: you added "well, *almost* never". What is a situation where '(' has a following whitespace or ')' has a preceding whitespace?
<pyc>
Is there any Emacs/SLIME/Paredit command to take the ugly style of *records* or *records3* at https://plaster.tymoon.eu/view/2314 and automatically reformat them in the *records2* style?
nullx002 has quit [Client Quit]
galex-713 has joined #lisp
Nilby has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
Noir has joined #lisp
attila_lendvai has quit [Ping timeout: 240 seconds]
g3n713m4n2 has quit [Ping timeout: 260 seconds]
<warweasle>
I read a study by NAVSEA about comparing various languages. Lisp seemed thrown in as an afterthought and it seemed like they were pushing for Haskell. The Lisp programmer showed up late and then cranked out the code in a few hours and would have won the competition IF they thought lisp was a viable language.
galex-713 has quit [Remote host closed the connection]
galex-713 has joined #lisp
nullx002 has joined #lisp
<warweasle>
Always wondered who that was...
rumbler31 has joined #lisp
nullx002 has quit [Client Quit]
nullx002 has joined #lisp
nullx002 has quit [Read error: Connection reset by peer]
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
orivej has joined #lisp
galex-713_ has joined #lisp
nullx002 has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
Noir has quit [Quit: Leaving]
nullx002 has quit [Client Quit]
<jealousmonk>
warweasle: that's interesting! do you have a link to this study?
galex-713_ has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
nullx002 has joined #lisp
<markasoftware>
If :lambda-list is passed to ensure-generic-function, and an :argument-precedence-order was previously set, is the argument-precedence-order discarded?
<markasoftware>
and reset to just the order of the required arguments in the lambda-list
nullx002 has quit [Client Quit]
galex-713 has quit [Ping timeout: 272 seconds]
nullx002 has joined #lisp
nullx002 has quit [Client Quit]
nullx002 has joined #lisp
<markasoftware>
ok i guess it is
<markasoftware>
i should have tested that before asking
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 256 seconds]
amk has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
amk has joined #lisp
abhixec has quit [Quit: leaving]
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #lisp
attila_lendvai has joined #lisp
dbotton has joined #lisp
ljavorsk has joined #lisp
galex-713 has quit [Ping timeout: 264 seconds]
Jesin has quit [Quit: Leaving]
paul0 has quit [Remote host closed the connection]
landakram has joined #lisp
paul0 has joined #lisp
amk has quit [Read error: Connection reset by peer]
zxcvz has quit [Quit: Leaving]
galex-713 has joined #lisp
Jesin has joined #lisp
galex-713 has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
campy_fellow has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
SAL9000 has quit [Quit: WeeChat 2.9]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
SAL9000 has joined #lisp
anticrisis has joined #lisp
nullx002 has quit [Read error: Connection reset by peer]
long4mud has joined #lisp
nullx002 has joined #lisp
<beach>
pyc: When the last thing before a `)' is a comment, the `)' must be on a separate line.
<warweasle>
In defmethod, I can I specify a particular array size? Like an array of matrices? Would that make the code faster?
dbotton has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
amk has joined #lisp
<Josh_2>
What do you mean?
<Josh_2>
You could define a type that is an array of a certain size and then use that as a type specifier in defmethod I suppose
mathrick has quit [Ping timeout: 240 seconds]
<Alfr>
That won't work, method dispatch works with classes only---not types.
<warweasle>
Alfr: Ok, thanks!
midre has quit [Ping timeout: 264 seconds]
<Josh_2>
oh right
galex-713 has quit [Ping timeout: 272 seconds]
midre has joined #lisp
<Alfr>
warweasle, but you can still write an optimized function (declare (type ..) ..) and arrange to call it if the type is correct (see typep).
dbotton has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
galex-713 has joined #lisp
landakram has quit [Ping timeout: 240 seconds]
rogersm has quit [Quit: Leaving...]
Lord_of_Life has quit [Ping timeout: 240 seconds]
<warweasle>
Alfr: I might do that later... If I need more speed. It's just a simple IIR filter so...