tyson2 has quit [Remote host closed the connection]
dnhester26 has quit [Remote host closed the connection]
<yates_work>
i've been an emacs user for 25 years, and therefore also have written elisp for that amount of time (mainly my own little helper functions). could someone give me an idea of how common lisp differs from elisp?
<aeth>
faster
<aeth>
more modern
<yates_work>
faster to write, or faster to execute?
<aeth>
both
<aeth>
Emacs Lisp is a clone of the Lisps that Common Lisp was meant to supersede and was intentionally archaic because RMS didn't like CL or lexical scope.
epony has quit [Remote host closed the connection]
<random-nick>
iirc RMS said he opted for dynamic scope because he thought it was easier to implement
<skin>
Feels like common lisp is a strict superset of those things.
<aeth>
WHILE is a while loop? eww.
<aeth>
I guess there are some things, a few things, that are surprisingly different
<random-nick>
it probably feels so because they took the same inspirations
<skin>
Assignment: setq is possible, but everyone uses "setf" now, which is "better"
<aeth>
there's no point to have WHILE in CL
<random-nick>
and of course there's the cl package which implements a lot of CL stuff, including LOOP
<aeth>
yes, SETQ is very archaic, an elisp-ism
<aeth>
SETF is basically SETQ-and-more and since it's a compile time macro why not use it
<skin>
Elisp is interpreted, common lisp is standardized, but in practice it is compiled.
<random-nick>
elisp is also compiled
<aeth>
Common Lisp isn't single implementation, so people move to the fastest implementations
<aeth>
although I guess there's XEmacs elisp, too
<yates_work>
in my current application, speed is not important. it will probably run sloppily in 0.05 seconds and efficiently in 0.0005 seconds - doesn't matter too much.
<yates_work>
(for a human)
<skin>
Still, I'm looking around in the elisp manual and I'm seeing a lot of familiar faces. defun, catch, throw, etc. It's almost like RMS was working with a lisp that predated the common lisp standard when he wrote emacs.
<yates_work>
the PCL introduction says CL's compiled speed is roughtly equivalent to C. I haven't tried lately, but I used to be able to beat the C compiler by a factor of 5.
<ixelp>
SBCL: the ultimate assembly code breadboard - Paul Khuong: some Lisp
<random-nick>
there are many usecases in between "elisp's performance is good enough" and "I'm going to write it in assembly for speed"
<aeth>
yates_work: although I think SBCL had some breaking changes to its asm since that was published in early 2014
<yates_work>
random-nick: for sure. no argument.
<aeth>
random-nick: why stop at that when you can use butterlies? https://xkcd.com/378/
<ixelp>
xkcd: Real Programmers
<aeth>
*butterflies
<yates_work>
lol
<yates_work>
i've seen that.
<random-nick>
also, since elisp is married to emacs, you get things like very featureful strings, buffers, and an easy way to make TUI for free
<random-nick>
while for CL you'll have to seek third-party libraries
<yates_work>
yay emacs!
<aeth>
on the other hand, CL gets you 3D
<yates_work>
aeth: which library?
<yates_work>
3D graphics?
<random-nick>
and for strings, they'd probably end up not being compatible to CL strings depending on what features you need and your implementation
<random-nick>
there are of course downsides to being married to emacs, like not being able to block on the main thread and only one thread being able to run at a time
<random-nick>
well, you can hang the main thread if you're running the code in a separate emacs and not the emacs you're actively using
<yates_work>
can a cl (e.g. sbcl) "application" be target-compiled to a standalone executable to run under linux or windows?
<yates_work>
(of course DLLs or shared libraries are permitted)
<random-nick>
what do you mean by target-compiled? compiled on the target (as opposed to cross compiled)?
<yates_work>
i mean compiled to an executable, rather than running in a REPL
<yates_work>
to a native executable.
donleo has quit [Ping timeout: 252 seconds]
<yates_work>
to an ELF file
<yates_work>
(for linux)
<random-nick>
yes, sbcl can do that, but it puts itself whole into the executable
<yates_work>
that's ok.
<random-nick>
somewhat similar to emacs' former unexec mechanism, but less hacky
<aeth>
yates_work: cl-opengl, among others
<aeth>
though there are higher level layers such as sketch, cepl, etc.
<ixelp>
GitHub - Shirakumo/trial: A fully-fledged Common Lisp game engine
<aeth>
yates_work: the gist of it is that most people who want to do 2D or 3D graphics in a Lisp seem to settle on CL, though a few settle on a Scheme.
<ixelp>
Common Lisp · lispgames/lispgames.github.io Wiki · GitHub
<random-nick>
also, I'd say that CL generally has a better selection of libraries compared to elisp, if you exclude all the elisp libraries related to text editing
<aeth>
lists are a bit noisier, though
<aeth>
i.e. there's a ton more on that list than I gave, but I mostly gave an overview (left out a few, I'm sure)
tyson2 has joined #commonlisp
<yates_work>
although i briefly considered it, i am not planning on using elisp for my project. my question on cl vs elisp was more to prepare my mind for the change in paradigm shift when i begin coding cl
<yates_work>
aeth: of course. what you gave is a nice start.
<olnw>
Elisp also lacks multiple values (its cl-values is merely an alias for the `list' function)
<yates_work>
the other serious contender was C++, which i am very comfortable with. but Seibel's intro to PCL has stirred an enthusiasm that is tipping the scales to cl
<yates_work>
since my project is a "parser", it seems cl is particularly well-suited
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
<aeth>
parsers are nice in CL
Lord_of_Life_ is now known as Lord_of_Life
<aeth>
even recursive but the standards people will shout at you for assuming so because it's not guaranteed, unlike in Scheme
<aeth>
i.e. tail calls are probably optimized. probably.
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
not enough to build your whole language's iteration around it, like in Scheme, but nice for parsing
<random-nick>
there are also parser generators which are just macros, instead of a separate language with a separate compilation step like for C
<aeth>
that takes away the fun of it
<aeth>
it's nice to write a parser
NotThatRPG has joined #commonlisp
<aeth>
you can of course be as high level as you want because of macros. You can just have a gigantic 1000 line declarative define-foo macro that describes it
<yates_work>
aeth: would you recommend cl-opengl as the goto-opengl library?
<yates_work>
can you write cl-opengl-generated images to svg file?
<random-nick>
that doesn't really make sense? svg is a vector format and opengl is a hardware-accelerated raster library
<paulapatience>
It is also possible to statically link SBCL
<aeth>
yates_work: cl-opengl is the go-to opengl library... easiest way to take advantage of it for some static image is to screenshot it (though it's not in pure CL), though SVG usually isn't what you want for that, though I'm sure you can generate an SVG from a screenshot PNG
<Alfr>
random-nick, you can stash bitmaps into svgs; not saying anyone should.
<paulapatience>
SBCL-built executables, I mean
<random-nick>
well, cl-opengl is not pure CL either
<aeth>
I guess take the screenshot as the screenshot extension for stumpwm (a CL tiling WM) if you want to keep it purist CL and get an image from OpenGL
<aeth>
though personally I take my screenshots under stumpwm with `import` from ImageMagick (and for all I know, the screenshot extension does too)
<random-nick>
and there's probably some way to make PNGs out of opengl framebuffers, maybe sdl (also not pure CL) has something for that
<aeth>
Alfr: you can also vectorize PNGs with tools
<aeth>
random-nick: yes, but that's far, far, far more work
<aeth>
random-nick: you absolutely can write images from OpenGL because that's basically how deferred shading works afaik
josrr has quit [Remote host closed the connection]
<aeth>
except instead of feeding it into the next render pass, you'd feed it into... well, not pngload because that just loads
<aeth>
I guess opticl
<random-nick>
if you want to make 2d vector drawings in svg format (which is the usual usage of svg?) then something like https://cliki.net/cl-svg is probably a better bet
<ixelp>
CLiki: cl-svg
<random-nick>
mcclim also has a relatively new svg backend afaik
<yates_work>
aeth: heck no. no no no. i want a vector svg out of the thing. if cl-opengl can't do that, it's not suitable for my purpose.
kristjansson has joined #commonlisp
<yates_work>
random-nick: yes, that is why i was asking about svg the other day
<yates_work>
i'll go with cl-svg then
<aeth>
yeah, you (almost certainly) don't want SVGs from OpenGL because OpenGL is a rasterizer so you're kind of working backwards
<aeth>
you (usually) start with vectors (nothing's stopping you from using voxels or whatever instead) and then rasterize it to pixels
Josh_2 has quit [Read error: Connection reset by peer]
<aeth>
and something 2D that uses it like Sketch is probably acting very SVG-like in its API
dra has quit [Ping timeout: 260 seconds]
thuna` has quit [Quit: out]
rbcarleton has joined #commonlisp
rtypo has quit [Ping timeout: 256 seconds]
<random-nick>
regarding mcclim, it's a whole GUI library that's pretty complex, but also has output-only backends for its 2d drawing API for svg, pdf, postscript and raster images
<random-nick>
sadly the only fully featured backed is for X11
<random-nick>
but if you need just svgs, going with cl-svg might be the better option because you don't have to learn mcclim and you might get better output
<random-nick>
same for cl-pdf if you only need pdfs, etc.
<aeth>
hopefully one of the 3D engines can be turned into a wayland compositor, though idk how much work that would be
epony has quit [Remote host closed the connection]
epony has joined #commonlisp
epony has quit [Remote host closed the connection]
yitzi has quit [Remote host closed the connection]
epony has joined #commonlisp
epony has quit [Remote host closed the connection]
epony has joined #commonlisp
jmdaemon has joined #commonlisp
dstein64- has joined #commonlisp
dstein64 has quit [Ping timeout: 264 seconds]
dstein64- is now known as dstein64
akoana has quit [Quit: leaving]
micro has quit [Remote host closed the connection]
micro has joined #commonlisp
random-nick has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
miique has joined #commonlisp
kristjansson has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #commonlisp
elderK has joined #commonlisp
zeka_ has joined #commonlisp
zeka has quit [Ping timeout: 268 seconds]
kristjansson has joined #commonlisp
random-jellyfish has joined #commonlisp
random-jellyfish has quit [Changing host]
random-jellyfish has joined #commonlisp
markb1 has quit [Ping timeout: 245 seconds]
tyson2 has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 255 seconds]
markb1 has joined #commonlisp
<yates_work>
in emacs, you can get help on any elisp function via C-h f <function> RET. is there a similar thing for cl under emacs/SLIME?
<yates_work>
nm
<yates_work>
that was lazy. i'm rtfm
<yates_work>
(the slime manual)
Kyuvi has quit [Ping timeout: 250 seconds]
<beach>
yates_work: It is good you didn't go for C++, because not only is the language very complex, it is also impossible to write a large C++ program that is both modular and fast. But I have said this many times, so I probably won't repeat it.
markb1 has quit [Ping timeout: 245 seconds]
markb1 has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
random-jellyfish has quit [Ping timeout: 260 seconds]
decweb has quit [Ping timeout: 276 seconds]
<yates_work>
beach: thanks for your confidence and faith in my abilities..
* yates_work
reminds himself that 26 years writing C++ is still the beginner stage..
<beach>
Common Lisp takes a while to learn as well, at least of you want to be good. But it is a much simpler language.
<beach>
yates_work: I am not sure whether that remark of yours was sarcastic, but I have absolutely no doubt about your abilities. But I can't say I have confidence in them either, because I haven't seen much of your work.
<elderK>
I have been summoned by the talk of C++, Common Lisp and Learninations!
<elderK>
But also: Happy Near Year in advance, guys!
<elderK>
May you have many enjoyable days of Lisp ahead in 2024 :)
pfdietz has quit [Ping timeout: 250 seconds]
<elderK>
yates_work: I'm primarily a C/C++programmer, too. I've been playing with CL for many years but haven't really done anything truly serious yet :) I wish you luck in your Lisp journey.
<beach>
elderK: What is holding you back from using Common Lisp? Is it just that you need more time?
<elderK>
Hey beach!
<beach>
Hello.
<elderK>
It's time but also having hard time breaking C/C++ preconceptions.
<elderK>
It may also just be that the things I want to work on, are not that good of a match for Common Lisp.
<beach>
I see.
jladd- has quit [Ping timeout: 245 seconds]
<elderK>
I figure it's inexperience more than anything - there is a lot I still don't know.
jladd has joined #commonlisp
<beach>
Sure. Lack of experience is fixable.
<elderK>
For instance, take arrays in CL. In C++, when I have a vector, I can specify whether that vector will contain instances of whatever type by value, or whether it will contain references to instances of whatever type.
<beach>
But I am curious about things that are not a good match for Common Lisp. I can perhaps imagine the lack of certain libraries.
<beach>
But why would you want to do that?
<beach>
I would phrase that as "In C++, when I have a vector, I HAVE TO specify..."
<elderK>
Having to specify sucks but it's useful to be able to control how things are laid out: For efficiency purposes, it is great to have all elements of a vector be allocated in contiguous memory.
<beach>
I can see that, but then I can also see that the overall performance of most applications would suffer from that. Because then, when you want to pass an object to a module, you have to copy it.
<elderK>
That's not necessarily true: You can pass by reference.
<beach>
But then your modularity goes down the drain.
<beach>
Hence "you can't write a program that is both modular and fast".
<beach>
But I fully admit that there are applications where you don't care about modularity.
<elderK>
What do you mean by modularity here? Even in CL, when you pass something, you may not always be passing a deep copy but instead a reference, right?
<elderK>
You have a lot more knowledge than me here, beach so I am very keen to hear what you have to say. Why would passing a reference to some data break modularity?
<beach>
Yes, but then the module and the client of the module must have a very tight relationship about what it does with the objects.
<beach>
But again, some applications don't need modularity.
<elderK>
Perhaps not. Generally if you are passing some instance to another module, by reference, there will be a convention as to how that object is to be used. You might be passing it by const-reference, so that you can query it without performing a copy.
<elderK>
Passing by mutable reference is considered a bad smell mostly.
<beach>
But then you can't have a module that holds on to the object.
<elderK>
No, you still can.
<elderK>
Just because you pass it by reference doesn't mean you cannot copy that.
<elderK>
It's just under your control when that copy is made.
<beach>
Oh, but if you copy, your performance goes down the drain.
<beach>
<beach>
So either your modularity or your performance goes down the drain.
<elderK>
Yes but it would be the same in CL, right? If we pass a reference to something to some function, that function may or may not mutate it. So, you might pass a copy instead.
<beach>
Well, that *might* be the case. But if a module might mutate an object, it does so because it's the very purpose of that module.
<beach>
So you would not copy an object just to be sure it doesn't get mutated.
<elderK>
Right but in this case, how does that differ from C++?
<elderK>
There, if we had some module that was intended to mutate some data, and we pass it a reference to that data, well, it can mutate it. How is that any different?
<elderK>
The module dosn'
<elderK>
Sorry - ergonomic keyboard. The module doesn't care where the thing lives, as long as it can access and modify it. If it is intended that other modules be able to hold onto that stuff, then that would have to be factored into the original design.
<elderK>
If that's the case here, then I agree, that sucks.
<elderK>
beach: I would love to be able to use CL as my primary language, for all things. Even today, I tell my wife about CL :P
<beach>
In a language without automatic memory management, you must have a much tighter coupling between a module and its clients. If a module doesn't mutate an object, you would either still have to pass it by reference for reasons of performance, or you would have to copy it. In the first case, modularity suffers, and in the second case, performance does.
<elderK>
Right - because the modules have to have some protocol to control when some shared data is released, if you pass things by reference and don't want to copy.
<elderK>
That's fair.
<elderK>
In C++, you can opt to use more GC-like behavior. You could for instance, use shared_ptr or weak_ptr.
<elderK>
Granted, those are reference-counted so probably aren't as efficient or safe as a proper generational GC.
<beach>
Yes, and then your performance goes down the drain.
<elderK>
I do have a question for you - and it might help my misunderstanding of performance cost.
<beach>
A simple assignment like a = b turns into "decrement the reference counter of a (which is a memory operation), check whether it is 0 (and if so, deallocate), increment the reference counter of b (which is another memory operation), and then assign".
<elderK>
So, in C/C++, allocation is seen as something that is very expensive. Most programmers these days don't care so much but people who've been coding for a lot longer may still expect an allocation to be very expensive. Excessive indirection, too. That's why we tend to use stuff like vector<Foo> rather than vector<unique_ptr<Foo>>.
<elderK>
But, in something like Lisp, the GC is very smart: Allocation is cheap because you're probably just bumping a pointer in some nursery or something.
<elderK>
So, even though your vector of objects is all references to instances allocated from the heap, it's probably closer in memory.
<elderK>
beach: Yup.
<hayley>
shared_ptr *is* garbage collection.
<elderK>
hayley: I know. It's RC.
<beach>
That's possible, but not guaranteed. But again, I fully understand that there are applications with extreme performance needs, like keeping things close in memory. I am just saying that then modularity becomes a problem.
<ixelp>
JVM Anatomy Quark #11: Moving GC and Locality
<elderK>
Aye: I see modularity issue now, too. Dealing with those issues is very much part of being a C++ programmer. It becomes kind of a second-nature thing. You're right - it does hurt modularity.
<elderK>
There are a lot of things a C++ programmer will work around without even really thinking that hard about it.
<hayley>
Someone showed me a program which runs 30% slower with my GC, due to worse locality, due to my collector usually not moving objects.
<beach>
elderK: And I claim the maintenance burden will increase as a result.
<elderK>
beach: And you'd be right :)
<elderK>
You see? :P C/C++ preconceptions holding me back.
<beach>
elderK: Take a program such as MuseScore. I see absolutely no reason to write such a thing in C++.
<elderK>
Agreed.
<elderK>
I think hardware is fast enough now that even for stuff that may have once required a language like C or C++, higher-level languages are more than good enough. Say, C# and Unity for tons of games. C# and XNA for others.
<beach>
Oh, and they write it in C++ for speed, but then they stick in a scripting language implemented as an interpreter. So when people write scripts, performance suffers even more.
<elderK>
Heh. That's an excellent point :P
<elderK>
One of my favorite games - Homeworld 2 - does that. Their engine is mostly C++, but then the core gameplay logic is Lua.
<beach>
If it were written in Common Lisp, there would be a single language, and user scripting code could be compiled.
<elderK>
Yup and if you really needed to, you could still implement "super performance conscious" parts in something else and call it from CL.
<beach>
That would be a much better strategy.
<elderK>
Something else I have to get used to, and it may also be a "meh" thing is that in C++, you generally always know how large things are. Say, if your class contains a num_whatever member, you can decide whether that counter will be 8, 16, 32, 64 bits in length. That's not a great example. A better example would be if you're say, implementing an emulator and want to very efficiently access parts of emulated memory or tweak bits of
<elderK>
the emulated machine's registers.
<elderK>
Is it correct that you can do the same in CL, provided you specify the proper type information?
<beach>
Hard to say (for me). But we are again talking about extreme performance, and I totally understand why applications with extreme performance needs must be written in a language where you can guarantee memory layout.
<elderK>
I wish there was like, a strange in-between: Syntax like Lisp but behavior kind of a mix of both C and CL.
<beach>
But things like score editors, word processors, spreadsheets, aren't such applications.
<elderK>
Although I imagine the two approaches are kind of diametrically opposed.
<beach>
Still they are written in C++.
<elderK>
Aye. I see no reason they can't be in CL.
<elderK>
Probably in C++ just because "more mind share."
<beach>
Yes, and that's the reason of the absolute disastrous state of the software industry.
<elderK>
Almost ten years ago, I was working at an eCommerce company. There, I managed to get one of my colleagues interested in CL and Scheme. My boss at the time, however, well, he was less than great. He ridiculed me for my interest in CL, and for teaching my friend.
<elderK>
People have a very strange view of Lisp. Even today, most people don't know that it can be really, really fast. I bet most of the time, SBCL and CL in general are probably just as fast as C# or faster. And yet, C# is everywhere.
<beach>
Yes, that's know as having a "closed mind set". Such people are very dangerous. Check out the writings of Carol Dweck.
<elderK>
Here in NZ, CL jobs are nowhere, C++ jobs are rare and C# jobs are *everywhere*
<hayley>
The hell of systems programming is the systems, not that the systems aren't programmed with prefix notation.
<elderK>
So going to quote you, hayley.
<elderK>
:)
<beach>
elderK: I have probably asked this before, but where in Aotearoa are you located.
<elderK>
NP :) I live in Christchurch, a city in the South Island.
<beach>
elderK: I see. When I spent my year in Auckland, I found that there were around 5 Lispers within a radius of a 3 hour flight.
<beach>
In Europe, there are hundreds.
<elderK>
beach: Wow. I wish I could've found so many. When I was at University in Dunedin, people were not very interested in Lisp. Some of the professors liked Lisp but no students.
<hayley>
elderK: Or quote Bob Barton: "Systems programmers are the high priests of a low cult."
<elderK>
Aye :) I remembering running into some French people while on a bus ride between cities: They knew I was writing Scheme. They were AI researchers, I think. Nice people.
<elderK>
beach: When did you spend your year in Auckland?
<elderK>
I lived there around 2014-2015, moved back to Dunedin in 2016 and to Christchurch in 2019.
<beach>
I would have to check. A long time ago now. Probably more than 15 years ago.
<elderK>
Wow :) I wonder how much different it was back then.
<beach>
I am guessing "very".
<elderK>
:P I have been collecting old machines, mostly because I'm curious how different writing software was back in the 80s or early 90s, from now.
<beach>
2005-2006 it seems.
edgar-rft has quit [Ping timeout: 245 seconds]
<elderK>
Wow. Maybe there are like, Lisp groups around here that I haven't found.
edgar-rft has joined #commonlisp
<elderK>
It'd be really neat to ask and learn from people like, in the flesh.
<beach>
I started the NZCLUG then.
<beach>
But it didn't survive my leaving.
<elderK>
:( That'll explain why Google had no results.
<elderK>
That really sucks :(
<beach>
That would be New Zealand Common Lisp User Group.
<elderK>
:) I will give CL another shot.
<elderK>
Even though I don't use it often, or for anything real, I still enjoy reading about it a lot and I would like to use it for real stuff.
<beach>
elderK: Perhaps you could pick up one of the projects I list on my "suggested projects" page.
<ixelp>
GitHub - robert-strandh/Cluster: Assembler with input in the form of standard instances
<elderK>
Neat :) I'll take a peek.
<beach>
Great!
<elderK>
Hopefully what I learned from LiSP will be helpful :)
<beach>
The book?
kristjansson has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
That's a great book, especially the English version. It's because of the excellent translator.
<elderK>
Aye. There was an exercise there, where a naive interpreter was written. But, instead of just you know, evaluating the source as it went, it translated everything into objects, first. Then executed them.
<elderK>
I love that book. :)
<beach>
The translator is my wife.
<beach>
If you come to ELS and bring your copy, she will sign it for you. :)
<elderK>
:D WOW!
<elderK>
She did a very good job!
<beach>
Yes, indeed.
<elderK>
Please send her my profuse thank yous, as all of that knowledge would've been inaccessible to me without her work.
<beach>
Will do.
olnw has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1.90)]
<elderK>
:P How much money would it take to translate the latest LisP edition? :P
<elderK>
Heh.
<beach>
Let me put it this way.... The money she made for that translation paid for my private sauna. :)
<beach>
Custom made.
olnw has joined #commonlisp
<elderK>
Too bad we couldn't like, get a GoFundMe or Kickstarter going :)
<beach>
You would still have to find a translator. I am pretty sure she wouldn't do it again.
<elderK>
I bet it was a huge job.
<elderK>
My wife is a part-time writer, I can respect how hard it is to write a story, littlelone translate something else.
<beach>
Yeah, I think she went to Paris to see the author pretty much every week for quite a while.
<elderK>
Wow. Did she (you guys?) live in Europe then?
<beach>
Yes, we have lived here since the end of 1987.
<elderK>
Wow :) That was when I was born!
<beach>
Heh.
<elderK>
My wife is from Texas but has a love for Britain and Europe in general. We both hope to visit some time in the future. Whenever we talk about where we will go, I always try to wiggle in a visit to somewhere where a Lisp conference or something might be :)
<elderK>
I'd love to meet you and others here. Also, some of the #chicken Scheme crowd. They are really nice people, too.
<beach>
Oh, my wife is also originally from Texas. Interesting.
<beach>
I say plan to go to ELS 2024.
<beach>
And the preceding SBCL conference too.
<elderK>
Man, what a small world.
<elderK>
:P San Antonio by chance?
<beach>
No, Houston.
<elderK>
That's cool :) I'd like to visit there sometime, too, just for the NASA stuff.
Guest24 has joined #commonlisp
<beach>
She says that Texas is a good place to be FROM.
<ixelp>
ELS 2024, Vienna - European Lisp Symposium
<beach>
Yes.
<elderK>
That'd be awesome although I doubt I'd be able to get that time off work :(
<beach>
:(
<beach>
There are usually more than 75 participants, and sometimes as many as 90.
<elderK>
Man, that's awesome.
<elderK>
Is ELS yearly?
herjazz has joined #commonlisp
<beach>
It is.
<beach>
In a different European city every year.
<elderK>
Perhaps in a year or so :) I'll bounce the idea to my wife :P
Alfr has quit [Remote host closed the connection]
<elderK>
If there's ever one in Ireland, she'd jump for joy.
Alfr has joined #commonlisp
<beach>
We would need a volunteer to organize it.
<beach>
But if you know someone, then have that person volunteer and it will very likely happen.
<elderK>
I don't know anyone but I will do my best to become friends with an Irish lisper :)
<beach>
Good plan! :)
NicknameJohn has quit [Ping timeout: 246 seconds]
<Guest24>
Hi, would any body help me find out why a ironclad rsa signature different from what is signed with openssl? The code is at https://plaster.tymoon.eu/view/4058
Guest24 is now known as tsanhwa
Aesth has joined #commonlisp
monospod has joined #commonlisp
azureuser has joined #commonlisp
azureuser has quit [Remote host closed the connection]
azureuser has joined #commonlisp
azureuser has quit [Remote host closed the connection]
azureuser has joined #commonlisp
<olnw>
beach: Is the English title of the "LiSP" book "Lisp in Small Pieces"?
<beach>
Yes.
<olnw>
Great. I'll see if I can find a copy.
<beach>
I think it is still available, but it might be expensive.
<beach>
olnw: It is not for application programmers. It is about how Lisp is implemented.
<olnw>
Well, I am interested in learning about such things.
<beach>
Good. Just wanted to make that clear.
markb1 has quit [Ping timeout: 268 seconds]
attila_lendvai has joined #commonlisp
markb1 has joined #commonlisp
markb1 has quit [Max SendQ exceeded]
markb1 has joined #commonlisp
dcb has quit [Quit: Connection closed for inactivity]
cage has joined #commonlisp
<beach>
olnw: Also, feel free to ask questions here.
azimut has joined #commonlisp
pve has joined #commonlisp
drakonis has quit [Quit: WeeChat 3.6]
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
dcb has joined #commonlisp
_cymew_ has joined #commonlisp
shka has joined #commonlisp
donleo has joined #commonlisp
dino_tutter has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
dajole has quit [Quit: Connection closed for inactivity]
<dnhester26>
olnw: yes, that's exactly right. I didn't even remember anymore and just read the last commit in the source folder which github adds in the top and it's exactly what you said: https://github.com/lisp-docs/cl-standard/tree/master/dpANS3R%2B
<dnhester26>
olnw: "created dpANSR3+ which is dpANS3 with the dpANSr changes applied for …ease of use... there is nothing new here..."
<dnhester26>
olnw: will change it now
<paulapatience>
beach: Where can I find more info about the SBCL conference?
<beach>
Not sure, sorry. I am mainly interested in ELS. I think SBCL is Thursday and Friday preceding ELS.
<beach>
May 2-3.
Gleefre has joined #commonlisp
<beach>
It is called SBCL25, presumably referring to the age.
<beach>
But I see no further information about it yet.
attila_lendvai has quit [Ping timeout: 256 seconds]
ym has joined #commonlisp
kristjansson has joined #commonlisp
kristjansson has quit [Client Quit]
<olnw>
beach: Thank you. I have recently had a renewed interest in programming, especially Common Lisp. I hope that when I am more advanced, I can help with some of your suggested projects.
<olnw>
dnhester26: You say "The CL Hyperspec is the only rendering there is based on this document [the ANSI standard] besides ordering a paper copy from ANSI." I don't think that's true, since Allegro also hosts a free online rendition of the standard.
<dnhester26>
yeah, syntax, where to put them mostly
<dnhester26>
in functions, generics, methods, clos, etc...
<beach>
I prefer to keep them separate from the code, using (SETF DOCUMENTATION) because documentation strings are noise to the person reading the code; they are meant for the user, not the maintainer.
<beach>
But otherwise, you could provide documentation strings for every entity that is part of the protocol.
<beach>
It is a bit silly to provide documentation strings for internal entities since they don't really have a user separate from the maintainer.
* beach
vanishes for a while.
<jcowan>
The difficulty with out-of-band doc strings is that they require an extra step by the person writing the code, which has to be enforced by more painful code review.
<beach>
The difficulty with in-band documentation strings is that they represent noise to the person reading the code, thereby discouraging sufficiently good documentation strings in favor of short, useless ones.
<beach>
... like the one for CAR in SBCL.
<jcowan>
As for silly, the maintainer is not the only user, because maintainers change over time in two senses: a new human being may be the maintainer, or even if the person is the same, the personality changes -- "old men forget", and young ones too, given the distractions of life.
<jcowan>
But I certainly agree that documenting things that don't need documenting merely to meet an arbitrary target *is* silly.
<jcowan>
On C++, note that it is perfectly possible to do C++ with garbage collection. I retrofitted a C interpreter that was riddled with allocation bugs with the BDW GC, and poof, 30% of the code vanished.
<jcowan>
A huge improvement.
<jcowan>
(Granted, I had written an interpreter for the same language in Scheme first.)
<jcowan>
s/a C interpreter/an existing C interpreter written by someone else/
<Shinmera>
People in C++ love to use garbage collection anyway, they just call it "smart pointers" and other silly stuff
<jcowan>
Fair, but in this case I meant conventional non-moving GC rather than reference counting.
<jcowan>
(If you are going to call refcounting "GC" on theoretical grounds, what do you call what the rest of us call "GC"?)
<moon-child>
tracing gc
<dnhester26>
in-band meaning in the code itself and out-of-band meaning with setf?
<jcowan>
Thanks.
<jcowan>
Yes, at least whne I say it.
varjag has joined #commonlisp
<dnhester26>
thanks
<jcowan>
finally, of course both performance and modularity can be achieved without GC of any sort, if you have enough money, brains, and time to do the necessary manual proofs. After all, humanity got people to the Moon and (more importantly) safely back to Earth with 1960s technology, both hardware and software.
igemnace has quit [Ping timeout: 245 seconds]
<Shinmera>
they still had a memory leak tho
<Shinmera>
(lol)
epony has quit [Remote host closed the connection]
_cymew_ has quit [Ping timeout: 252 seconds]
skyl4rk has joined #commonlisp
epony has joined #commonlisp
Inline has joined #commonlisp
Kyuvi has joined #commonlisp
dino_tutter has joined #commonlisp
<beach>
jcowan: Comments, not documentation strings, are for the maintainer.
<beach>
Remarks meant to clarify to a maintainer how the code is written and why it is written that way, belong in comments.
<hayley>
jcowan: Someone once said that text rendering is harder than getting to the moon and back. I wonder if that's true, and how big the gap is.
makomo has quit [Quit: WeeChat 4.1.2]
random-jellyfish has joined #commonlisp
<beach>
I once consulted for a company that had written a biggish application in C++ and they had problems both with memory leaks and with freeing live objects. So I suggested the use the Boehm-Demers-Weiser garbage collector. The two project leaders then told me that they thought it was the responsibility of the programmers to "clean up after themselves".
<beach>
I was so dumbfounded I didn't know what to say.
<jcowan>
"Then stop pissing on them", would have been my response.
<jcowan>
Or a softer variant if I thought I could change leaders' minds.
<beach>
If I had had a bit more presence of mind, I would have discouraged the use of a call stack that automatically cleans up the activation record after a function call.
<jcowan>
I was married for 40+ years to a teacher, who was committed to the belief that everyone's mind can be changed. I was unable to share her view.
<beach>
The CTO saw my point but didn't manage to convince the project leaders. Eventually the project was canceled with millions lost.
<jcowan>
yes, unfortunately CTOs have authority but little power.
<beach>
Indeed.
<jcowan>
(of course, some have no authority either)
<jcowan>
A friend of mine was a CTO for five years and described it as "a hideous trap"
<beach>
Well, they are usually not trained in the domain, so they usually have to trust the project leaders and programmers. But this one at least was able to understand my argument.
random-jellyfish has quit [Ping timeout: 268 seconds]
<jcowan>
hayley: That's easy to see: the Moon missions *worked*. Text rendering often fails.
varjag has quit [Ping timeout: 260 seconds]
dino_tutter has quit [Ping timeout: 256 seconds]
varjag has joined #commonlisp
varjag has quit [Ping timeout: 260 seconds]
elderK has joined #commonlisp
igemnace has joined #commonlisp
mgl has joined #commonlisp
herjazz has quit [Quit: leaving]
dra has joined #commonlisp
dra has quit [Changing host]
dra has joined #commonlisp
dino_tutter has joined #commonlisp
<younder>
My CTO at Opera was Håkon Lie - the creator of CSS. Maybe I was luckey
Equill has quit [Quit: Gone offline]
<beach>
Are you saying CSS is considered a good thing?
dino_tutter has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]
mgl has quit [Ping timeout: 256 seconds]
jonatack has joined #commonlisp
lucasta has joined #commonlisp
jonatack has quit [Ping timeout: 260 seconds]
dnhester26 has quit [Remote host closed the connection]
tasty has quit [Quit: bye bye!]
tasty has joined #commonlisp
tasty has quit [Changing host]
tasty has joined #commonlisp
rainthree has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
dnhester26 has joined #commonlisp
chomwitt has quit [Ping timeout: 260 seconds]
Equill has joined #commonlisp
<aeth>
amusingly, these days, reference counting has managed to spin itself as "not garbage collection" so if you found a group opposed to "garbage collection" you can probably just pitch reference counting to them
<beach>
Oh, so "we don't want that efficient stuff, and instead something with a huge overhead and that is incapable of managing cyclic data"?
<beach>
Clearly we (collectively as computer science academics) totally failed in our mission to train future software developers.
<aeth>
software's a weird field because it has been growing so rapidly that the majority of programmers at any given time are newbies, making the same mistakes over and over again, and they might even find some success (in users or financially or both)
<aeth>
even if you taught everyone the right way in 2024, then they'd be outnumbered by 2029
<beach>
But they are outnumbered because industry insists on hiring poorly trained (and therefore not very productive) people who produce unmaintainable (and apparently deliberately slow as well) software.
<aeth>
they are poorly trained and therefore not very productive, but they cost less money to hire
<aeth>
or they just try their hand at releasing code to the internet directly
<aeth>
and before you know it, millions of people depend on is-even
<beach>
But someone should do the calculation. Then they would see that the additional cost of a better trained person is worth every currency unit.
<Equill>
At my last employer, somebody raised the question of what would happen if you assembled a group of the smartest, most knowledgeable developers you could find, and a group of totally average ones, and independently set them to the same task.
<beach>
So they are also outnumbered because the people hiring are incapable of measuring (and even guessing) the effects of productivity in software development.
<Equill>
One of the smarter developers asserted that the very bright group would have some *really interesting* discussions, and the mediochre developers would actually produce something.
<aeth>
yes
<aeth>
clashing egos and stuff
<aeth>
there are probably 2-5 architectural answers to any given problem (or heck just 2-5 ways to write any line item in a style guide), and everyone will probably have a favorite solution
<beach>
As if that problem does not exist with poorly trained people?
<beach>
It is probably worse there, because many of the poorly trained people are also in the "closed mindset" category.
<edgar-rft>
According to my experience the main problem is that in a two-years-warranty world nobody ist interested in selling code that still can be understood or maintained *after* two years because otherwise no customer would want to pay *again* as soon as the warranty is over.
<Equill>
The ego problem exists there as well, but I agree with him that the mediochre types are more likely just to hammer something out. It'll be a pile of spaghetti, but it'll compile, run and solve the problem to a first approximation.
<aeth>
it's already happened... software already got good enough and stable enough so they have to (1) constantly change the underlying APIs so the old stuff breaks just due to attrition and (2) charge subscriptions because nobody would buy version n+1 if version n still runs
<Equill>
My last employer had that problem, to an extent: customers starting to ask why they were paying all this money in support fees. There was a period when it was relatively stable, and they were working on "engine-room" stuff that would enable future expansion; from the outside, it looked like not much was going on.
<pfdietz>
It's interesting comparing the stability of commercial Common Lisps and free Common Lisps. I tried running the random tester on a beta of the former recently, and it would just crash.
<Equill>
Personally, my problem lies in making a hosted service good enough that people would want to pay for it.
elderK has quit [Quit: Connection closed for inactivity]
dino_tutter has joined #commonlisp
jonatack has joined #commonlisp
lagash has joined #commonlisp
jonatack has quit [Ping timeout: 255 seconds]
olnw has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
lucasta has quit [Quit: Leaving]
zxcvz has joined #commonlisp
zxcvz has quit [Client Quit]
varjag has joined #commonlisp
mgl has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
waleee has joined #commonlisp
mgl has quit [Ping timeout: 268 seconds]
Inline has quit [Ping timeout: 256 seconds]
mgl has joined #commonlisp
reb has quit [Remote host closed the connection]
reb has joined #commonlisp
jonatack has joined #commonlisp
waleee has quit [Ping timeout: 245 seconds]
mgl has quit [Ping timeout: 260 seconds]
waleee has joined #commonlisp
jonatack has quit [Ping timeout: 260 seconds]
Aesth has quit [Read error: Connection reset by peer]
NicknameJohn has joined #commonlisp
dajole has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
Inline has joined #commonlisp
josrr has quit [Read error: Connection reset by peer]
Jach has quit [Ping timeout: 276 seconds]
Jach has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
Aesth has joined #commonlisp
waleee has quit [Ping timeout: 255 seconds]
josrr has joined #commonlisp
waleee has joined #commonlisp
yates_work has quit [Quit: rcirc on GNU Emacs 29.1]
yates has joined #commonlisp
<yates>
speaking of C++ vs. CL: how would you "declare" a vector of (e.g.) uint32_t's in CL?
<yates>
in C++: std::vector<uint32_t> myvec;
shka has quit [Ping timeout: 256 seconds]
tyson2 has joined #commonlisp
<beach>
yates: Declare or define? Define: (make-array n :element-type (unsigned-byte 32)) Declare (declare (type (vector (unsigned-byte 32))))
<beach>
yates: Er (make-array n :element-type '(unsigned-byte 32))
shka has joined #commonlisp
<beach>
... and (declare (type (vector (unsigned-byte 32)) <variable>))
<beach>
*sigh*
dra has quit [Ping timeout: 246 seconds]
waleee has quit [Ping timeout: 268 seconds]
ronald has quit [Read error: Connection reset by peer]
dnhester26 has joined #commonlisp
ronald has joined #commonlisp
<random-nick>
CL declarations and C++ declarations are entirely different things
<random-nick>
CL, like other lisps, does not have variable declarations, variables are instead bound by forms such as LET and only available to forms lexically inside that LET (or other form)
<Inline>
declare,declaim,proclaim
<random-nick>
Inline: I meant that as, CL doesn't have what is called a variable declaration in C++
<Inline>
hmm, ok
igemnace has quit [Quit: WeeChat 4.1.2]
blackshuck has joined #commonlisp
blackshuck has quit [Quit: Using Circe, the loveliest of all IRC clients]
rainthree has quit [Ping timeout: 268 seconds]
makomo has joined #commonlisp
waleee has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
josrr has quit [Remote host closed the connection]
_cymew_ has quit [Ping timeout: 260 seconds]
epony has quit [Remote host closed the connection]
skyl4rk has quit [Ping timeout: 245 seconds]
skyl4rk has joined #commonlisp
tyson2 has joined #commonlisp
miique has quit [Quit: Leaving]
drakonis has joined #commonlisp
anticomputer has joined #commonlisp
yitzi has quit [Remote host closed the connection]
makomo has quit [Ping timeout: 256 seconds]
epony has joined #commonlisp
mgl has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
<Inline>
happy new year
mgl has quit [Ping timeout: 246 seconds]
jrm has quit [Quit: ciao]
jrm has joined #commonlisp
ronald has quit [Ping timeout: 255 seconds]
Aesth has quit [Read error: Connection reset by peer]
ronald has joined #commonlisp
<aeth>
random-nick: yeah, I'm with Inline, CL does have variable declarations via declare (or, used very rarely, declaim for global special variables)
<aeth>
though, yes, they're different than C++'s
<Inline>
i just don't get proclaim
<Inline>
tried to use it once with utter fail
<random-nick>
aeth: I think the closest equivalent to CL declarations in C++ are attributes (via __attribute__ and [[ ]]) or #pragmas
<random-nick>
while a c++ declaration is a part of a block which defines new variables for that block
mgl has joined #commonlisp
<aeth>
random-nick: I suppose you could argue that (let (...) (declare (type ...)) ...) is the way to define new variable bindings, with types like in C++, but usually they are not provided, and when not provided, the type is T (the union type of every type, behavior decided by runtime type checking)
<aeth>
with T not being the same as C++'s auto, since it's not autoinferring the type, since you can SETF any arbitrary type to it
<random-nick>
still, LET is just another form, and the variables are only bound in its body, while a C-style variable declaration defines a variable in the block it is contained in
<random-nick>
I think schemes do have something similar, where their define defines lexical variables when it's not toplevel
varjag has quit [Ping timeout: 276 seconds]
<aeth>
{ ... } is pretty close to, but ofc distinct from, a LET
<aeth>
Scheme DEFINEs just create an implicit LETREC*
<aeth>
well, sorry, { ... } is pretty close to LET*
<bike>
this seems kind of distant from the original question.
<random-nick>
yes, it's maybe somewhat distant :)
notzmv has quit [Ping timeout: 246 seconds]
son0p has joined #commonlisp
mgl has quit [Ping timeout: 246 seconds]
oak has quit [Ping timeout: 252 seconds]
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
xlymian has joined #commonlisp
oak has joined #commonlisp
pve has quit [Quit: leaving]
Devon has quit [Ping timeout: 276 seconds]
ronald_ has joined #commonlisp
ronald has quit [Read error: Connection reset by peer]