patlv has quit [Remote host closed the connection]
patlv has joined #lisp
mange has joined #lisp
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
jack_rabbit has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Ping timeout: 244 seconds]
sauvin has quit [Remote host closed the connection]
nullniverse has joined #lisp
sauvin has joined #lisp
pjb has quit [Ping timeout: 256 seconds]
markoong has quit [Read error: Connection reset by peer]
pjb has joined #lisp
pjb is now known as Guest23048
Guest23048 has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 260 seconds]
Guest23048 has joined #lisp
JuanDaugherty has joined #lisp
Guest23048 has quit [Remote host closed the connection]
johnnymacs has joined #lisp
Guest23048 has joined #lisp
robotoad has joined #lisp
johnnymacs has quit [Remote host closed the connection]
Guest23048 has quit [Ping timeout: 240 seconds]
patlv has joined #lisp
brettgilio has joined #lisp
skapata has quit [Remote host closed the connection]
BitPuffin has quit [Remote host closed the connection]
ravndal has quit [Remote host closed the connection]
terpri has joined #lisp
Guest23048 has joined #lisp
ravndal has joined #lisp
Oladon has quit [Quit: Leaving.]
Guest23048 has quit [Ping timeout: 256 seconds]
brettgilio has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
brettgilio has joined #lisp
daniel-s has joined #lisp
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
pierpal has joined #lisp
Pixel_Outlaw has joined #lisp
pierpa has quit [Quit: Page closed]
Kundry_Wag_ has quit [Quit: Leaving...]
Guest23048 has joined #lisp
Kundry_Wag has joined #lisp
fikka has joined #lisp
karlosz has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
dmiles has joined #lisp
Guest23048 has quit [Ping timeout: 256 seconds]
dmiles has quit [Ping timeout: 244 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
robotoad has quit [Quit: robotoad]
Guest23048 has joined #lisp
dmiles has joined #lisp
rumbler31 has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 240 seconds]
patlv has quit [Ping timeout: 260 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Guest23048 has quit [Ping timeout: 276 seconds]
nullniverse has quit [Quit: Leaving]
eli_oat1 has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
marvin2 has joined #lisp
AetherWind has joined #lisp
fikka has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
rozenglass has joined #lisp
kajo has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
robotoad has joined #lisp
karlosz has quit [Quit: karlosz]
brettgilio has quit [Remote host closed the connection]
igemnace has joined #lisp
subr has quit [Read error: Connection reset by peer]
dddddd has quit [Remote host closed the connection]
brettgilio has joined #lisp
<loke>
So odd... It was pointed out on #emacs that CLHS doesn't seem to specify what the default comparator for FIND is. I know it's EQL, but where does it actually say so in the CLHS?
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<Lord_Nightmare>
has anyone considered making a more updated spec for common lisp than the 1988 one? how would one even create a commitee to do that?
<Lord_Nightmare>
is there a common lisp steering commitee?
<Bike>
it's a page that probably ought to be linked from more pages than it is
<Bike>
Lord_Nightmare: yes, pay ansi a whole lot of money, no
<loke>
Bike, yeah. I noticed. . :-)
<loke>
Thanks
Kundry_Wag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
eli_oat1 has quit [Quit: Leaving.]
makomo has quit [Ping timeout: 260 seconds]
milanj_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
brettgilio has quit [Remote host closed the connection]
panji has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
ldb has joined #lisp
fikka has joined #lisp
slyrus1 has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
anewuser has quit [Quit: anewuser]
brettgilio has joined #lisp
Kundry_Wag has joined #lisp
kdas_ is now known as kushal
equwal has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
brettgilio has quit [Remote host closed the connection]
<aeth>
Lord_Nightmare: You would have to get the authors of the various implementations to agree to it. At a bare minimum, SBCL and CCL. Either not participating would probably be enough to kill the effort. Of course, the other implementations (especially ECL, SICL, and Clasp, which are all active on IRC) should ideally also participate.
<aeth>
You don't need a new *ANSI standard*. It's not like any of us use the ANSI standard, anyway. We all use the Hyperspec and/or a freely available draft of the ANSI standard.
<aeth>
What you'd probably get are threads, unicode, paths, and whatever's currently trendy (pure functional programming? lazy lists? async/await?).
<aeth>
But you'd have to convince a lot of different people.
<aeth>
s/paths/fixed paths/
<beach>
Good morning everyone!
<mrcom>
aeth: sandboxed environments (Forget who's into that. beach: ?)
<aeth>
Also local package nicknames. That's another one that comes up all of the time.
ldb has quit [Quit: ERC (IRC client for Emacs 26.1)]
brendyn has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
krwq has joined #lisp
<beach>
Lord_Nightmare: Designing a language is tricky business. We are lucky that Common Lisp was designed by a collection of very smart and highly knowledgeable people, in contrast to some of the languages in use today. It is very easy to get it wrong if you are not a language expert and a compiler expert.
<beach>
Furthermore, Common Lisp has a commercial aspect to it as well. There are the two major vendors that need to be taken into account. So a committee would have to include representatives for them as well as people who know their technical details and their computing history.
fikka has joined #lisp
<aeth>
The free implementations that I know of are SBCL, CCL, ECL, ABCL, CLISP, CMUCL, MKCL, Clasp, Mezzano (I think it uses SBCL for bootstrapping and then runs its own implementation in the OS itself), and SICL. The commercial implementations that I know of are Allegro, LispWorks, Scieneer, Genera, and mocl.
fikka has quit [Ping timeout: 244 seconds]
Folkol_ has joined #lisp
<aeth>
If you wanted to be complete you could probably get away with just having representatives from SBCL, CCL, ECL, ABCL, CLISP, CMUCL, Clasp, SICL, Allegro, and LispWorks. That's 10: 8 FOSS and 2 commercial.
<aeth>
There are also other implementations that are dead, like GCL.
<aeth>
Those are just the implementations. There are other interests that would want representation, too.
dmiles has quit [Ping timeout: 244 seconds]
<aeth>
Even getting 10 people to agree on things would be difficult, though.
brettgilio has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
Lord_Nightmare has quit [Ping timeout: 260 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
loli has quit [Quit: WeeChat 2.1]
shka1 has joined #lisp
brettgilio has quit [Remote host closed the connection]
loli has joined #lisp
rippa has joined #lisp
Lord_Nightmare has joined #lisp
<krwq>
is there a way to get function/macro signature without defining a macro wrapper for defining them? (external library ok)
<krwq>
beach: before reading - does the page cover macros?
<beach>
I don't remember. Probably not.
<beach>
It is not required to return anything useful. The commercial vendors would be very upset if you could get the source of their compiler for instance.
vlatkoB has joined #lisp
<krwq>
beach: do you perhaps know of any library which would tell me compiler/interpreter infered types for the arguments as well?
<beach>
I think there is some code like that, but I don't personally remember where.
brettgilio has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
dmiles has joined #lisp
<Lord_Nightmare>
from what i gather, genera/opengenera seems pretty dead, except for a few people keeping it alive by keeping lisp machines running, and to some extent emulation
<Lord_Nightmare>
the only reason symbolics still exists in any form i think is because of some long government maintenance contracts, and i don't see those lasting more than another decade at most
<jeosol>
Morning beach. One virtual beer for you.
moei has quit [Quit: Leaving...]
<Lord_Nightmare>
hopefully once the money dries up, whoever owns it will dump what's left of it open under some sort of usable open source license
<jeosol>
Congratulations!!! to my French brethren for the world cup victory.
<jeosol>
btw, good discussion regarding CL above. One of my friends, not a CL user told me why I used a dead language ... lol
<jeosol>
for my project.
<Lord_Nightmare>
my issue with common lisp is from hearing that a lot of the idiosyncrasies in it date to incompatible implementations amongs the early lisp machines and forks in the late 70s/early 80s, which is why there are five subtly different equality comparison operators
<Lord_Nightmare>
and at least some of 'common lisp' was gathering up a lot of these differences and canonizing many of them in a giant common framework
<Lord_Nightmare>
its been 30 years since 1988, and much of the reasoning for having redundancy like there originally was is no longer really relevant anymore
<Lord_Nightmare>
I'm not advocating chopping anythig out of the language, but deprecating some stuff might be a good idea, for later removal
<beach>
jeosol: I'll transmit it to my (admittedly small) family who is a French citizen.
<Lord_Nightmare>
(i mean i'm not advocating chopping anything out immediately)
<beach>
jeosol: She is not much into beer though.
<beach>
Lord_Nightmare: What do you want with Genera?
<beach>
Lord_Nightmare: We can do better than that.
<Lord_Nightmare>
nothing, right now. I'd rather use a lisp implementation like SBCL that I can use on a modern system without having to jump through hoops
<Lord_Nightmare>
my issue with genera is i think it should probably be lumped in the 'dead' pile, at least very soon
<Lord_Nightmare>
unless the current owner(s) of symbolics want to keep it around, of course
red-dot has joined #lisp
<beach>
Lord_Nightmare: I don't quite understand what your agenda is. Why do you care about things you don't use?
<beach>
And who would be in charge of doing this "lumping"?
<Lord_Nightmare>
Musings, pie in the sky ideas which will never come to fruition :(
<Lord_Nightmare>
i haven't a clue.
<Lord_Nightmare>
i was just wondering if the idea had been considered before
<Lord_Nightmare>
anyway, I'm cluttering up the channel with my harebrained schemes, i'll shut up now.
Cymew has joined #lisp
<beach>
Lord_Nightmare: Ideas about updating the standard pop up here regularly, usually by relative newbies who know nothing about language design, compiler technology, garbage collection technology, synchronization primitives, or anything. They also know nothing about standardization, and the complex social interactions required to create a language like Common Lisp.
<mrcom>
Lord_Nightmare: Comes up frequently. It's kind of a rite of passage :)
Cymew has quit [Remote host closed the connection]
<mrcom>
Tidying-up is a powerful human drive.
Kundry_Wag has joined #lisp
Cymew has joined #lisp
<mrcom>
Fortunately, often, it's exceeded by drive to procastinate.
Kundry_Wag has quit [Ping timeout: 268 seconds]
rozenglass has quit [Remote host closed the connection]
nickenchuggets has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 248 seconds]
brettgilio has quit [Remote host closed the connection]
<Lord_Nightmare>
my idea was more to 'mark the less useful leftovers which could probably be removed', since i understand the roots of common lisp are over 50 years old and a lot of people poured a lot of thought into it
mm__redacted has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<Lord_Nightmare>
let me read thos
<Lord_Nightmare>
this
mm__redacted has joined #lisp
<beach>
Lord_Nightmare: That would be one of the less useful modifications. People can just ignore them. They only pose problems to people implementing Common Lisp systems.
saki has quit [Ping timeout: 264 seconds]
Guest38519 has quit [Read error: Connection reset by peer]
<beach>
Anyway, got to go.
<Lord_Nightmare>
i'm starting to understand that
<Lord_Nightmare>
l8r
saki has joined #lisp
kdas_ has joined #lisp
krwq has quit [Ping timeout: 244 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
saturn2 has quit [Ping timeout: 276 seconds]
kushal has quit [Ping timeout: 250 seconds]
anon has joined #lisp
anon has joined #lisp
anon has quit [Changing host]
anon is now known as Guest48278
orivej has joined #lisp
caltelt_ has quit [Ping timeout: 260 seconds]
froggey has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
<flip214>
beach: both, of course - winning, and completing! ;)
froggey has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 26.1)]
fikka has quit [Ping timeout: 248 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
moei has joined #lisp
red-dot has joined #lisp
saturn2 has joined #lisp
<LdBeth>
Good afternoon
scymtym has quit [Ping timeout: 240 seconds]
brettgilio has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 264 seconds]
easye has joined #lisp
daniel-s has quit [Remote host closed the connection]
mange has quit [Remote host closed the connection]
pierpal has quit [Ping timeout: 240 seconds]
<muresanvlad_>
how often does the garbage collector is called on average?
<beach>
muresanvlad_: That depends a lot on the behavior of your application.
<muresanvlad_>
very true
<beach>
muresanvlad_: Some people write applications that never allocate any memory. In that case the garbage collector is never alled.
<muresanvlad_>
but on average, can I expect it to be called once a second?
<beach>
called.
nirved has quit [Ping timeout: 276 seconds]
<trittweiler>
muresanvlad_, In a C program, how often do you think malloc is called on average?
nirved has joined #lisp
graphene has quit [Remote host closed the connection]
<muresanvlad_>
it's quite different. The GC can be called when you create a new variable,string or function
<muresanvlad_>
I wouldn't say malloc is called often though
pagnol has quit [Ping timeout: 240 seconds]
graphene has joined #lisp
<trittweiler>
Doesn't it depend on the way the program is written? A C program doing a lot of text processing, would call malloc quite often, no?
<muresanvlad_>
right, I just wanted to know for an average small program how often the gc can be called once per second
<muresanvlad_>
aproximative ofc
<loke>
muresanvlad_: It's more like once every few seconds for a minor collection (very fast)
<loke>
Major collections (the ones that take time) could be run every few minutes, even for large applciations. In some cases, several hours can pass.
<muresanvlad_>
^ that kind of response I was looking for
<muresanvlad_>
major collections?
<loke>
The ones that collect the older generations.
<loke>
Usually, GC's split their heap into generations, since it has been shown that most memory gets collected almost instantaneously.
<muresanvlad_>
so the marking stages doesn't go deeper every time?
muresanvlad_ is now known as Murii__
<beach>
muresanvlad_: There are small programs that don't allocate any memory, and there are others that allocate a lot. It is completely meaningless to talk about averages here.
<loke>
So memory gets allocated on the young generation, and after a while gets “promoted”. The old generation is only GC'ed when it fills up, which means that it can take quite some time becfore the majority of memory is ever GC'ed
<loke>
But, as Beach noted, different applications have different requirements.
<loke>
If you really want to, you can always look at the GC in a specific implementation (and its settings) and then write a program that directly targets theat particular GC implementation.
<loke>
Just like you can write programs that directly target the malloc implementation in a given operating system and trigger some naty behaviour (like fragmentation)
<aeth>
jeosol: The French drink virtual wine, not virtual beer.
xrash has quit [Ping timeout: 240 seconds]
<beach>
Murii__: Why do you care how often the garbage collector is called anyway?
<Murii__>
For getting an idea how much of an impact it has over the performance
<beach>
Murii__: Usually, none.
<loke>
Murii__: The number of times it gets called tells you nothing about its perfomance.
<beach>
Murii__: It can be amortized over the allocations your program executes.
<Murii__>
those checks ain't cheap
<aeth>
If you need to avoid the GC in part of your program or profile exactly where/when the allocations happen/etc., SBCL ime is the easiest for this.
<Murii__>
traversing the root and seeing which is marked and which is not
<beach>
Murii__: I think you are confused about what the GC does, and why it is called.
<aeth>
Murii__: It's pretty easy to see exactly how much or how little the GC is called in SBCL
<aeth>
Iirc, there's even a way to log it
<beach>
Murii__: There is a very deep result in the GC literature which is that as the size of your heap increases compared to the working set of your application, the cost of garbage collection as a fraction of your application execution time goes to 0.
<Murii__>
perhaps
<beach>
Murii__: People also imagine that manual memory management like malloc()/free() is cheaper than tracing garbage collection. That is not true at all.
<Murii__>
doubt that
<beach>
Murii__: Now I *know* that you are confused.
shifty has joined #lisp
<beach>
Murii__: The amount of work that malloc()/free() have to do is definitely not negligible. Do you know how an implementation of those works?
<Murii__>
you must be a very smart and dedicated C programmer
<beach>
Murii__: I just implemented a version of Doug Lea's algorithm, and I studied Paul Wilson's excellent survey paper about memory allocators.
heisig has joined #lisp
<beach>
Murii__: Again you are confused. The algorithms used by typical malloc()/free() implementations can be learned without writing a single line of C code. They general purpose allocator techniques that work in any language.
schweers` has joined #lisp
<beach>
They ARE general purpose...
<Murii__>
malloc will be called either way when you create a new variable in Lisp
<beach>
Murii__: Absolutely not.
<aeth>
Murii__: You probably shouldn't call beach a C programmer.
<beach>
Murii__: I think you need to read up on how garbage collection works.
<Murii__>
Why? Because I said malloc is called when you create a new variable?
<Murii__>
that's absolutely true
<beach>
Murii__: Nope.
<loke>
I also have experience in the subject. More so than the average programmer at the very least. I think a lot of people on this channel know what they are talking about.
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<lieven>
Murii__: go read up on the boehm-gc stuff for example. There are cases of existing C programs speeding up when linked with it. It basically replaces the stdlib's malloc/free pair with its own where free is a nop and does gc.
caltelt_ has quit [Ping timeout: 265 seconds]
makomo has joined #lisp
Kundry_Wag has joined #lisp
makomo has quit [Client Quit]
<schweers`>
beach: a garbage collecting system would not necessarily have anything directly resembling malloc, right?
<loke>
lieven: More accurate would be to say that it ‘may’ do GC.
<loke>
schweers: if you define malloc() as being “something that provides free memory to whomever requests it” then it must have. :-)
<Posterdati>
aeth: there was a prometheus/grafana example of sbcl GC statistics!!!
<schweers`>
I mean malloc as in malloc(3)
<beach>
schweers`: Exactly.
* jackdaniel
waits for infinite-memory-systems, where no garbage needs to be freed or collected :-)
<schweers`>
as in, only provide the amount of bytes one wants allocated.
<beach>
schweers`: It is usually much more efficient than that.
<schweers`>
thanks beach :)
<Murii__>
schweers`, boehm-gc under UNIX uses either malloc, sbrk, or mmap
<schweers`>
Murii__: quite possible, I wanted to know if it must be this way for all garbage collectors. I assumed that this is not the case, and beach confirmed this.
<loke>
jackdaniel: Some application are written as such. I've seen very memory hugly Java applications running with the GC turned off. They just restart the application every night (effectively creating a single GC :-) )
<loke>
hungry
<schweers`>
loke: my bias tells me that this is stupid. is there a legitimate reason for this?
<loke>
(they don't actually turn it off, but they set the heap size to a ridiculous size, and tune it so that it only GC's if it absolutely needs to, which is never)
<beach>
schweers`: A good Common Lisp system will have a "nursery", i.e. a generation of youngest objects from which new objects are allocated. And they use a copying collector, so that allocation is just a matter of testing and incrementing a pointer.
Folkol_ has joined #lisp
<schweers`>
wow, that really sounds like cheap allocation! I had no idea!
<loke>
schweers: well, they are essentially working around limitations in the software. As the customer dataset grew, they needed more and more heap. Once they git a heap size of around 50 GB or more, the full GC took so long that it blocked transactions in the system.
<beach>
schweers`: Whereas the standard implementation of malloc() has to look for a best-fit block among all free blocks in memory.
<loke>
s/git/hit/
<loke>
beach: No need to even test the pointer. An allocation is literally just an ADD instruction.
<schweers`>
loke: my question may sound naive but ... why not have smaller collections on the way? As far as I know, the jvm has this as default behavior anyway, right?
<beach>
loke: The heap might be full no?
<loke>
beach: You set of a readonly memory page after the free heap, and then you'll get a SEGV when you hit it, which can trigger a minor GC
<beach>
loke: Sure, that's one possibility.
<loke>
beach: That's how it's usualyl implemented.
<beach>
loke: I am surprised but I believe you.
<loke>
beach: THat'
<loke>
beach: That's the reason why you can't load the JVM into SBCL wusing FFI. Both of them tries to handle SEGV and they confuse eachother leading to a crash.
<beach>
Heh.
<loke>
it saves a conditional jump instruction (and perhaps a CMP, depending on how you lay things out in memory) per allocation. That adds up.
<beach>
I would think that cost would be swamped by the necessity of allocating memory in order to initialize the object allocated. Plus, the branch-prediction logic will guess the right thing almost all the time.
larme has quit [Quit: WeeChat 2.1]
<beach>
loke: But, I do believe you.
<trittweiler>
Posterdati, Might want to add a short section in the beginning what this is about. I didn't know what Prometheus.io is, and because the name of the library is essentially the same as that service, I didn't quite get it at first. (Usually, the convention used to be to call this thing cl-prometheus rather than prometheus.cl, but that's just names.)
<loke>
beach: I'm sure it's possible to avoid page table hackery, but how much you gain I don't know.
<loke>
The benefot of not doing it would be that you can easily link in the Java VM in the same process, which would be useful.
<schweers`>
it seems to me that low level languages like C have done so much optimization, that this way of handling memory and optimizing it is completely lost to them.
<beach>
loke: Me neither. But I'll find out one day.
<trittweiler>
Posterdati, I find the numbers in the tables confusing too. Is it really N (operations) per second? In that case, the implementation via mutex wins?
<beach>
schweers`: They can't do better if they assume that objects won't move once allocated.
<Posterdati>
trittweiler: ?
<schweers`>
exactly
<schweers`>
Is moving objects not at least somewhat expensive? It seems so to me, but then again, I don’t know much about GC.
<Posterdati>
trittweiler: what?
<trittweiler>
Posterdati, oh that link you posted, that's not your project? Sorry
<Posterdati>
trittweiler: no, it isn
<Posterdati>
trittweiler: no, it isn't
<beach>
schweers`: In my opinion, this is the reason for the complexity of C++. They made the decision from day 1 to use manual memory management.
<schweers`>
complexity ... that’s a nice way of putting it :-P
<beach>
schweers`: Sure, moving objects is not free.
<Posterdati>
beach: the complexity of C++ came from strostrup which is a puppet of the Majors
larme has joined #lisp
<Posterdati>
beach: c++ it is clearly a patch work
_cosmonaut_ has joined #lisp
krrrcks has joined #lisp
<schweers`>
not to bash on Stroustroup, but it seems to me like C++ is a quick hack gone too far.
<beach>
Posterdati: Here is how I see it. Common Lisp and other modern languages enforce uniform reference semantics. That is impractical without GC. Without it, you must distinguish between objects and pointers to them and you must be very careful when counting references and/or copying objects. That is a large part of the complexity of C++.
<loke>
schweers`: You should bash on him, because you're totally correct.
<schweers`>
nah, I disagree with him on language design, but I can kind of see how this can happen. Also, he did a remarkable job, in a way. I couldn’t have done what he has. Also, it was a different time.
<Posterdati>
beach: not to mention the different versions of c++
<schweers`>
I /do/ however bash on people who insist, that the language should still be used
<shka>
C++ is amazing set of features that don't really work together
<shka>
AKA bad design
<schweers`>
well, maybe for some really weird niche platform. But I guess there are better languages today for any purpose.
<Posterdati>
shka: lol
<shka>
manual memory managment is probabbly not the only reason behind it
orivej has joined #lisp
<shka>
personally i blame "let's put everything in!" mentality
<schweers`>
shka: templates look like botched design to me too
<Posterdati>
schweers: don't recall them to me, please...
<jackdaniel>
imo "let's put everything in!" is very lispish mentality
<Posterdati>
schweers: at my 40s I totally abandon c++ and learn CL due to templates
<shka>
jackdaniel: yeah, but somehow C++ failed at that really badly
<schweers`>
Posterdati: seems like a sane thing to do ;)
<trittweiler>
beach: C++ tries really hard to make it possible to use the stack for allocations because allocating on the stack is cheap (it's just a pointer increment! - oh the irony)
<schweers`>
trittweiler: LOL
<beach>
trittweiler: Heh!
<Posterdati>
schweers: it was, it was my friend!
<Posterdati>
schweers: In my case the Conrad Barsky song is fullfilled
figurelisp has joined #lisp
<shka>
honestly, what amazes me the most in CL is that most things work together
<shka>
on conceptual level almost everything is compatible
<schweers`>
shka: I’m afraid I don’t recall any details, but I remembering thinking that some things in CL seemed weird and somewhat arbitrary, until I got how they work together. Then it just seemed (and seems) amazing.
<Posterdati>
well every languages has got its own purpose, I still don't catch the c++ purpose, I mean it is not for system programming, nor for AI, databases? Who knows...
<schweers`>
Posterdati: it is sometimes used for embedded devices, as it has some features which make it a little more pleasant to use than C. Which says more about C than C++, if you ask me.
<Posterdati>
schweers: on Arduino is nice, but not desiderable, I use to program them using c...
<schweers`>
guess why I dislike embedded devices!
<aeth>
C++ seems to be very popular in high performance and/or real-time programs, e.g. game engines.
<Posterdati>
really?
skeuomorf has joined #lisp
<schweers`>
aeth: I wonder how much of this is just history, and how other languages (CL in particular) would fare in this domain
<Posterdati>
I found a lot of c++ in products like rhinoceros
<aeth>
Pretty much every game engine is C++, even if they let you use a different language for the part you write (like Unity's C#)
skeuomorf has left #lisp [#lisp]
EvW1 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<aeth>
schweers`: Well, as far as history goes, in the 1980s games were written mostly in asm, and portable games were written that way until probably 2004 or so. In the 1990s, games got to use C and about 15 years ago they switched to C++.
Kundry_W_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
shifty has quit [Remote host closed the connection]
marvin4 has joined #lisp
Kundry_W_ has quit [Ping timeout: 260 seconds]
<schweers`>
But even if CL were not a good candidate for AAA games, I guess that other languages might. Rust maybe?
<schweers`>
which is probably still awful
<schweers`>
anyway, this has gone a little off-topic
<shka>
schweers`: writing game engines is not the same as writing games
pagnol has joined #lisp
<schweers`>
shka: true, but I know too little about either to form an informed opinion
Folkol_ has joined #lisp
<shka>
schweers`: needlessly to say, currently you can simply grab unreal engine or unity engine and stick to it
<shka>
if you can somehow embedd lisp in it, you are golden
<aeth>
schweers`: The big problem with writing a game engine in Common Lisp (or, really, anything that's not C++) is that you have to do everything yourself instead of using existing solutions.
<aeth>
shka: That probably wouldn't work, but you could probably embed it in Godot
<_death>
did you realy suggest a language created less than a decade ago and constantly changing for a huge codebase?
dkrm has quit [Quit: WeeChat 2.1]
<aeth>
_death: It's already being done
<schweers`>
I didn’t realize that there were so many libraries that game engine developers could use.
<schweers`>
_death: in case you meant me suggesting rust, it was just a wild idea. I’m not seriously suggesting it, no.
<_death>
aeth: that foolish decisions are made is not an argument..
<shka>
anyway, i have problem with swank and tramp mode in emacs
<aeth>
This is definitely more of a #lispgames topic than a #lisp topic
<shka>
i am attempting to compile form using c-c c-c in file opened with tramp mode (ssh(
<shka>
but it won't work because of type error
<shka>
newest swank and slime on both sides
<shka>
it used to work
<shka>
what can be wrong?
<_death>
aeth: skimming it I did not see any indication of the code base size.. anyway, to me Rust is one of the most distasteful languages in use.. so I may be biased ;)
acolarh has quit [Ping timeout: 260 seconds]
lumm has joined #lisp
fikka has joined #lisp
AetherWind has quit [Quit: Leaving]
fikka has quit [Ping timeout: 276 seconds]
acolarh has joined #lisp
random-nick has joined #lisp
eminhi has joined #lisp
Kundry_Wag has joined #lisp
m00natic has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<eminhi>
hi, I'm getting a new deprecation warning in asdf
<eminhi>
Deprecated recursive use of (ASDF/OPERATE:OPERATE 'ASDF/LISP-ACTION:TEST-OP
<eminhi>
'("bugg-ba/test")) while visiting (ASDF/LISP-ACTION:TEST-OP "bugg-ba"))
<eminhi>
is recusive use of asdf operations b/w systems deprecated?
orivej has quit [Ping timeout: 268 seconds]
EvW1 has quit [Ping timeout: 240 seconds]
BitPuffin has joined #lisp
vlatkoB_ has joined #lisp
skapata has joined #lisp
vlatkoB has quit [Ping timeout: 265 seconds]
figurelisp has quit [Ping timeout: 244 seconds]
lumm has quit [Ping timeout: 244 seconds]
nirved has quit [Ping timeout: 276 seconds]
Cymew has quit [Remote host closed the connection]
hajovonta has joined #lisp
igemnace has joined #lisp
figurelisp has joined #lisp
fikka has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hajovonta has quit [Quit: hajovonta]
hajovonta has joined #lisp
<hajovonta>
hi
<figurelisp>
where did you guys learn dataq structures in lisp? Not the data structures implemented in lisp but to try to implement them.In a functional way
fikka has quit [Ping timeout: 256 seconds]
<eminhi>
Finally figured out, that the warning i got was due to defining test-system to run tests in test-op, not on load-op.
dddddd has joined #lisp
<hajovonta>
figurelisp: read lots of books and keep programming in lisp.
<LdBeth>
figurelisp: as long as you not modify it, it is immutable data structure
mejja has joined #lisp
graphene has quit [Remote host closed the connection]
<hajovonta>
unfortunately sometimes I had to look up functions like append and such in the beginning
<hajovonta>
to see if they are destructive or not
<hajovonta>
it would help if it were obvious from the naming :)
graphene has joined #lisp
<figurelisp>
there are books that teach to implement data structures like trees, graphs in imperative programming languages like java,c++ and others adn there is also data structures books for haskell, ML. Are there no books like these for Common lisp?
<figurelisp>
hajovonta: LdBeth
froggey has quit [Ping timeout: 240 seconds]
<LdBeth>
figurelisp: if you have already read those books i think the only additional thing you have to do is learning CLOS, which gives you the ability to implement complex data structures in CL
froggey has joined #lisp
Kundry_Wag has joined #lisp
<LdBeth>
And how to use the inspector
<LdBeth>
(It is a statement)
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
<beach>
figurelisp: An implementation in Common Lisp of some data structure would use exactly the same elements as are used in other languages. Common Lisp has vectors, lists, and standard objects which provide those elements.
<hajovonta>
it's not really harder or easier to implement complex data structures in CL than in other languages
<hajovonta>
the principles are the same.
<beach>
Exactly.
<hajovonta>
but it's admittedly more fun.
<hajovonta>
but, there is a fun book for CL I can recommend, Land of Lisp
<hajovonta>
landoflisp.com
<beach>
figurelisp: Now, what do you mean by "In a functional way"? Do you mean that the data structure is persistent (in the sense that applying an operation to it generates a new instance and leaves the original one intact), or do you mean that you want to implement traditional data structures that can be mutated but you want to use a functional style for the implementation?
<hajovonta>
it shows how to implement data structures for simple CL games.
<hajovonta>
there is even a section for functional programming.
random-nick has quit [Read error: Connection reset by peer]
<beach>
figurelisp: If it is the former, then you just follow the literature on how such data structures are implemented. If it is the latter, then you are looking in the wrong direction, because Common Lisp is not a particularly "functional" language in that respect. You would rather use standard objects and generic functions in an imperative style.
<figurelisp>
by functional I mean no mutation
<beach>
figurelisp: I understand that part.
<beach>
figurelisp: I am asking whether you are referring to the property of the data structure you want to implement, or to the programming style to do it.
<figurelisp>
programming style i think
<figurelisp>
like the basic dataq structures are implemented in haskell but they are functional
<beach>
figurelisp: You can do that in Common Lisp, but that's not the typical Common Lisp style.
Kundry_Wag_ has quit [Remote host closed the connection]
eminhi has quit [Quit: leaving]
Kundry_Wag has joined #lisp
<figurelisp>
I don't know much about functional programming so i am not certain how they are implemented. I was thinking to learn functional paradigm through CL
Kundry_Wag has quit [Remote host closed the connection]
<antoszka>
figurelisp: You can, but CL won't really be helping you with that.
<figurelisp>
ok
<beach>
figurelisp: What antoszka says. Common Lisp shines with its object system, its condition system, etc. Not for its support for functional programming.
Cymew has joined #lisp
<antoszka>
figurelisp: It doesn't force you into functional thinking (like Clojure/Haskell do), nor does it really provide any strictly functional facilities.
<beach>
But you can definitely use a functional style in Common Lisp. It is often done to implement macros for instance.
<antoszka>
Sure.
<figurelisp>
My main objective is to learn CL. Now i am reading CL:gentle introduction but after that i thought the next path would be to learn how to implement basic data strucutes. that's all what i want to achieve right now
<beach>
figurelisp: That's a good idea. But I would scratch the "functional" goal then.
<figurelisp>
ok
<beach>
figurelisp: You would have simpler data structures and a more natural Common Lisp programming style.
<figurelisp>
But i am stil not clear on how to proceed on learning data structure path
<beach>
figurelisp: Perhaps you should start with something simple, and we can show you.
<beach>
figurelisp: Like a stack, for instance.
<figurelisp>
so what you are saying is I should try to implement it on my own and then ask for help and code review here?
<edgar-rft>
figurelisp, there'a ton of builtin data structures you can use, we would need to know more details what you need exactly
<beach>
Or, we can show you, and you can do the next one.
<beach>
figurelisp: It's up to you.
<figurelisp>
ok
<figurelisp>
but how did you learn
<beach>
figurelisp: The stack is particularly simple for the very simple case, but I can show you situations where the simple case is inadequate.
<figurelisp>
beach: sorry to interrupt but i will not be abel to understand it right now. I'll complete the introdution book and then i'll learn from you
<figurelisp>
very soory
<beach>
OK.
<hajovonta>
figurelisp: I did Project Euler exercises
<hajovonta>
and learnt through doing. I recommend the same
<beach>
figurelisp: Let us know when you want help.
<figurelisp>
hajovonta: ok
<figurelisp>
thank you beach
lumm has joined #lisp
<figurelisp>
thank you everyoen
<hajovonta>
beach: oh come on. (defparameter stack nil) (push 1 stack) (push 2 stack) (pop stack):)
<beach>
hajovonta: That won't respect the most elementary restriction on an imperative data structure, namely that it has its own first-class identity.
flamebeard has quit []
<LdBeth>
Now we want a dequeue
orivej has joined #lisp
<beach>
hajovonta: Try (defparameter stack2 stack1) then (push 234 stack1). For it to be moodular, stack2 must change as well. Otherwise, your implementation is showing in the interface which is unacceptable.
cyberlard has quit [Ping timeout: 256 seconds]
<beach>
hajovonta: Elementary data structure design.
flamebeard has joined #lisp
<beach>
hajovonta: The Common Lisp list is not an abstract data type. I call it a "concrete" one. So it can be used to implement an abstract data type, but it can't be used as such by itself.
fikka has joined #lisp
<LdBeth>
I would prefer an array with a fill pointer
<beach>
LdBeth: Like I hinted, there are problems with each one.
<beach>
LdBeth: The array with a fill pointer has the problem that you can not guarantee, nor even come close to, O(1) complexity for the operations.
<beach>
LdBeth: The list version has the problem that if you want a stack of (say) DNA letters, then storing 2 bits costs you 126 bits overhead.
<beach>
LdBeth: So it is not a simple question of preferring one to the other. It has to do with conforming to specifications. In the case of a stack, I can eliminate both problems with a slightly more complicated implementation.
<hajovonta>
it would be interesting to create a closure-based implementation and see comparisons.
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<beach>
hajovonta: That would be essentially the same as the one that uses a standard class above, except it would be less flexible.
<beach>
hajovonta: The closure would play the same role as the instance of the standard class.
pierpal has joined #lisp
<LdBeth>
Closure is just one kind of data structure
Kundry_Wag has joined #lisp
pierpal has quit [Quit: Poof]
Kundry_Wag_ has joined #lisp
pierpal has joined #lisp
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
<shka>
i use flexichains as queues
<shka>
if that's even relevant here
<shka>
^_^
Folkol has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
cyberlard has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag_ has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag_ has joined #lisp
<LdBeth>
beach: why array with fill pointer can’t guarantee O(1) complexity, except you mean when the stack is full and needs to be resized
Kundry_Wag_ has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Murii__ has quit [Ping timeout: 256 seconds]
<hajovonta>
beach: I would think, after reading let over lambda, that closures are more flexible than using objects.
<hajovonta>
on a certain level.
<hajovonta>
but for a particular task, it may be impractical to use them.
* LdBeth
no lambda :(
random-nick has joined #lisp
<LdBeth>
Yes lambda is proven capable for anything, but don’t take it as everything
Kundry_Wag has quit [Ping timeout: 240 seconds]
<_death>
objects are poor man's closures, and vice versa..
acolarh has quit [Ping timeout: 265 seconds]
Smokitch has quit []
nowhere_man has joined #lisp
pagnol has quit [Ping timeout: 260 seconds]
nowhereman has joined #lisp
nowhere_man has quit [Ping timeout: 245 seconds]
nowhereman is now known as Guest39745
milanj_ has quit [Quit: This computer has gone to sleep]
acolarh has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
DGASAU` is now known as DGASAU
Kundry_Wag has joined #lisp
Bike has joined #lisp
schweers` has quit [Ping timeout: 240 seconds]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
daniel-s has joined #lisp
schjetne has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
mindCrime has joined #lisp
pjb has joined #lisp
red-dot has joined #lisp
pfdietz has joined #lisp
pagnol has joined #lisp
Kundry_W_ has joined #lisp
<pfdietz>
Vectors with fill pointers can implement stacks in O(1) amortized time per operation.
<pfdietz>
This is fine unless you have real time constraints, or if you're trying to make the stack "fully persistent" (where updates can be done on past versions in a branching model of time.)
<beach>
pfdietz: Correct. I was referring to the worst-case complexity of one single operation.
<beach>
hajovonta: You would be thinking wrong.
<pfdietz>
It's possible to get to O(1) worst case time by a more clever approach, where the copying to the new larger vector is spread out over O(n) updates. This still doesn't help with full persistence though.
<beach>
hajovonta: You can't stick an auxiliary method that specialized according to the particular type of the closure.
<beach>
... for instance.
Kundry_W_ has quit [Ping timeout: 244 seconds]
<pfdietz>
Another lispy example of this is implementation of a queue with stacks. Using two stacks you can do queue ops in O(1) amortized time, but you can also do it in O(1) worst case time with some effort.
mindCrime has quit [Ping timeout: 248 seconds]
<beach>
pfdietz: The better solution that solves both problems is to use a list of constant-size vectors.
Kundry_Wag has quit [Ping timeout: 240 seconds]
kuwze has quit [Quit: Page closed]
<beach>
pfdietz: Interestingly, when I came up with that solution, I checked it with the algorithms and data structures expert in the lab (I do not consider myself an expert, though I may have to rethink that), and he had never heard of it, nor had he ever contemplated the problems with the list or the vector solution (space vs real-time).
patlv has joined #lisp
<flip214>
ping easye
pjb has quit [Ping timeout: 248 seconds]
<shka>
that does not sound expertish to me
pjb has joined #lisp
<beach>
I agree. That's what surprised me.
<shka>
btw, how is your data structure book going?
<pfdietz>
I don't understand.
pjb is now known as Guest1775
<beach>
shka: No progress for some time. Still nearly finished.
<shka>
oh, ok
<beach>
pfdietz: Which part? The problems or the solution?
Guest1775 is now known as pjb`
pjb` is now known as pjb
nika_ has joined #lisp
<pfdietz>
What you said is not making sense, so I'm not sure which.
Kundry_Wag has joined #lisp
<shka>
it makes perfect sense actually
<pfdietz>
Not making sense TO ME. :)
<shka>
ok
<shka>
can i explain?
<pfdietz>
Yes
<beach>
pfdietz: Using a list to implement a stack has the problem that each element takes 2 words. So if you want a stack of bits or of DNA letters, you wast a lot of space.
<beach>
pfdietz: Agreed?
<pfdietz>
Yes
<pfdietz>
Ah, so the point was to save space, thus the vectors? Ok.
warweasle has joined #lisp
<beach>
pfdietz: If you use a vector instead, you are sacrificing real-time behavior, so you can't propose it to gamers for instance. Occasionally an operation may take linear time.
<beach>
If you use a list of constant-size vectors, you can have vectors of bits, and provided the vector is big enough, you can make the 2 words waste arbitrarily small.
<Zhivago>
Gamers don't really care about real-time -- they just care about latency spikes. In practice they just make things excessively fast enough that the spikes they do get are acceptable.
<pfdietz>
There's a theme in data structure design where you layer two different kinds of data structures, using a different one for small chunks. This looks like an example of that.
<beach>
pfdietz: Furthermore, you only ever need to allocate a constant-size vector and you never need to move more than that many objects, so you have constant time operations.
<beach>
Zhivago: Fine, you got me. I should have used a different example.
<pfdietz>
And the overhead of the links can be spread over the length of the vectors, and so can be made as small as desired.
Folkol has joined #lisp
<beach>
Yes, that's what I meant by "you can make the 2 words waste arbitrarily small".
<pfdietz>
I understand now.
<beach>
Great! I haven't totally lost my ability to explain.
<beach>
Phew!
<Zhivago>
I think you'll find that gamers are happy with the terrible things that STL does to extensible vectors in most cases. :)
<TMA>
Zhivago: constrained latency is one way to define a real-time system
<Zhivago>
They're just not so happy about unbounded latency spikes from things like GC.
<pfdietz>
Where I was not clear was that you were reducing the space overhead, minimizing the constant.
<beach>
Zhivago: I actually don't care much about that particular use case. I chose the wrong example. Again, I'm sorry.
lumm has quit [Ping timeout: 260 seconds]
<shka>
there are areas in modern game engines that should be real time
<beach>
pfdietz: I see.
milanj_ has joined #lisp
<shka>
anyway, it you can have hard real time behavior as a component in system that is supposed to have soft real time characteristics without drawback, you potentially can save yourself headache when optimizing
<shka>
and yes, STL vectors realocations can supermurder your performance
<shka>
especially if it is combined with memory fragmentation
<shka>
and usually it is
<shka>
... and this is how is stopped worry and loved the GC
eli_oat1 has joined #lisp
<shka>
manual memory managment is just so time consuming and prone to errors
<shka>
and you will need to put so much extra effort just to get even with GC
eli_oat1 has quit [Client Quit]
schweers` has joined #lisp
<pjb>
Sometimes, stacks are not stacks, but trees…
<shka>
sometimes vectors are not vectors, but trees...
<pjb>
it's easier to make trees of cons cells :-)
<shka>
debatable
EvW has joined #lisp
<beach>
pjb: Clearly, for the side-effect-free version of the stack, the vector solution is totally out. The list of constant-size vectors might still be acceptable.
<beach>
pjb: In fact, now that I think of it, it is entirely feasible.
<beach>
pjb: If you have very small objects, like bits or DNA letters, you can copy the entire thing very efficiently, so you are no worse off than with a pure list.
<beach>
pjb: And if you have large objects, you converge toward the pure list solution anyway.
<beach>
pjb: Glad you pointed that out. :)
<pjb>
This is why we have programmers: there are always special circumstances that require specific data structures and algorithms.
<beach>
Indeed.
JuanDaugherty has joined #lisp
flamebeard has quit []
EvW has quit [Ping timeout: 260 seconds]
LiamH has joined #lisp
sjl_ has joined #lisp
Kundry_Wag_ has joined #lisp
vlad_ has joined #lisp
scymtym_ has joined #lisp
saki has quit [Quit: saki]
moei has joined #lisp
scymtym has quit [Ping timeout: 265 seconds]
shrdlu68 has joined #lisp
igemnace has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
pjb has quit [Ping timeout: 240 seconds]
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
hajovonta has quit [Quit: hajovonta]
DingoSaar has joined #lisp
mindCrime has joined #lisp
patlv has quit [Ping timeout: 264 seconds]
milanj_ has quit [Quit: This computer has gone to sleep]
pagnol has quit [Ping timeout: 265 seconds]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
patlv has joined #lisp
igemnace has joined #lisp
saki has joined #lisp
puchacz has joined #lisp
hhdave has joined #lisp
shrdlu68 has quit [Ping timeout: 244 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
pagnol has joined #lisp
patlv has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
shrdlu68 has quit [Client Quit]
light2yellow has joined #lisp
<flip214>
Xach: "The libraries were last updated on April 30, 2018." << yesterday, IIRC
lumm has quit [Read error: Connection reset by peer]
ofi has quit [Remote host closed the connection]
<JuanDaugherty>
so the problem I was having with mcclim demo was due to trying to run under vnc
<beach>
Oh, good not know.
<JuanDaugherty>
couldn't find the one I tried but another similar worked fine with regular X
<JuanDaugherty>
under xmonad actually
patlv has joined #lisp
FreeBirdLjj has joined #lisp
brettgilio has quit [Remote host closed the connection]
heisig has quit [Quit: Leaving]
<Bike>
somewhat to my surprise, you can pass any input stream to LOAD, as far as i can tell. but if you do, and the stream has no associated file, i'm not sure what *load-truename* and *load-pathname* ought to be bound to. anyone know?
DingoSaar has quit [Ping timeout: 240 seconds]
<JuanDaugherty>
maybe /dev/null ?
<Bike>
on sbcl it's still nil, looks like
<JuanDaugherty>
i thought you meant you needed to bind to some file
<shka>
this sounds like neat feature
milanj_ has joined #lisp
<Bike>
I mean, for example, in (with-input-from-string (s ("print *load-pathname*)") (load s)), what is printed.
<JuanDaugherty>
standard input would be a choice to if you wanted to accept more
<Bike>
"(print i mean.
<JuanDaugherty>
*a choice too
Kaisyu has quit [Quit: Connection closed for inactivity]
<Bike>
that's not how load-pathname works.
<beach>
Bike: Good question. I don't see the answer to it anywhere. Something for WSCL to specify, it seems.
<JuanDaugherty>
oh yeah forgot context
<Xach>
flip214: Thanks for the notice. I have a few updates to do for the web page!
vlatkoB_ has quit [Remote host closed the connection]
fikka has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
karlosz has joined #lisp
FreeBirdLjj has joined #lisp
DingoSaar has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 244 seconds]
Murii has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
sendai_ has joined #lisp
shka1 has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
azimut has quit [Ping timeout: 260 seconds]
HighMemoryDaemon has joined #lisp
patlv has joined #lisp
<HighMemoryDaemon>
Can Lisp be compiled to machine code that can be ran on computers without [insert common lisp implementation] installed?
<brettgilio>
HighMemoryDaemon: Yes, of course there are lisps that compile to native.
<brettgilio>
That is one of the strengths of lisp.
eli_oat1 has joined #lisp
<brettgilio>
The fact that most of them interface with C to render complete native runtimes.
<random-nick>
HighMemoryDaemon: does that disqualify implementations that bundle themselves with your executable?
<Bike>
you generally need some kind of support library, though.
<trittweiler>
Note: he's asking to run the binary without a Lisp runtime
<random-nick>
yeah, you'll always need at least a part of implementation
<HighMemoryDaemon>
Bike: What would the support library do?
<Bike>
provide definitions of standard functions. like libc.
<random-nick>
even if you somehow don't use any standard functions and macros you still have the garbage collector
<Bike>
beefier though.
<trittweiler>
HighMemoryDaemon, ECL can get you binaries that simply depend on a libecl.so dynlib.
<sjl_>
depends on what you mean by "installed". If you s-l-a-d on sbcl, it can produce a single binary that doesn't need anything else on the target machine to run.
<random-nick>
HighMemoryDaemon: SBCL can save a full image of the running system as an executable
<sjl_>
That binary will happen to include SBCL itself, so whether you consider that to be "installing" SBCL on the target machine depends on your definition of installing, I guess.
<aeth>
As far as standalone binaries, SBCL wil be the fastest, but the largest, so it depends on what you want. Probably unsuitable for a tiny script, but probably most suitable for a game or large application.
puchacz has quit [Quit: Konversation terminated!]
<random-nick>
also, a big downside of SBCL is the static limit on heap size
<sjl_>
I've never found it to be a very big downside, for the kind of stuff I write
<earl-ducaine>
HighMemoryDaemon: For the sake of completeness: the degree of local support needed for compiled code is unspecified, i.e. implementation dependant and can be , and for modern common ilsp often is, zero
<HighMemoryDaemon>
Just compiled a console hello world program in SBCL. 42 megabytes in total.
hvxgr_ has joined #lisp
Posterdati has quit [Ping timeout: 256 seconds]
<Bike>
beeeeef
<aeth>
On the other hand, even graphical applications are much larger than 42 MB these days. Bloat.
<aeth>
(Although you can somewhat avoid that with vector assets.)
<aeth>
s/even graphical/even small graphical/
<pjb>
HighMemoryDaemon: with ecl, you can also generate a static library libecl.a, and link your program statically, so the executable doesn't rely on a shared library to be pre-installed.
<HighMemoryDaemon>
pjb: That's interesting. Will have to check it out.
<random-nick>
HighMemoryDaemon: yes, that's because SBCL includes itself in every executable
<random-nick>
as in, the whole thing
<sjl_>
HighMemoryDaemon: Right, that includes SBCL itself. e.g. if your hello world app crashes you'll get the full debugger and Lisp environment.
<marvin4>
is there a way to avoid packing sbcl together with every executable? or do language spec require full enivornment available at runtime
<aeth>
I wonder if that makes some antiviruses false positive on SBCL
red-dot has joined #lisp
<Bike>
i don't think sbcl supports an "sbcl library", but ecl does.
<pjb>
marvin4: yes, instead of using sbcl, use another CL implementation. Then sbcl won't include itself with the executable.
xaotuk has quit [Ping timeout: 260 seconds]
<Bike>
seriously, you could just not answer
<pjb>
aeth: that's because lisp implementation write to executable memory.
Kundry_Wag_ has joined #lisp
<HighMemoryDaemon>
What are the most common uses of Lisp in the modern day? GUI applications, web servers, AI, ..? I have a feeling that with a lot of uses you don't need to worry about compiling to native machine code.
<aeth>
pjb: So what you're saying is that Lisp is unprotected from buffer overflows? :o
<pjb>
Worse! It's unprotected from self-modifying programs!
<Bike>
compiling to native code is usually useful. compiling gives you static error checks, and machine code is generally faster than interpretation.
<pjb>
Can you imagine? We can use CL:COMPILE at run-time!
<pjb>
Anathema!
eli_oat1 has quit [Quit: Leaving.]
<Bike>
it is a general purpose programming language. do people ask what java is "for"? it's such a weird question to me
<aeth>
HighMemoryDaemon: Two uses are common enough for their own channels: #lispgames and #lispweb
<aeth>
Lisp was also traditionally very large in AI, but it was mainly used for old school AI, not machine learning, so relatively speaking it's probably much smaller there than it was.
<pjb>
and then, there's cl-cuda…
<earl-ducaine>
HighMemoryDaemon: If you're concerned about the size there are various compression schemes you could lookat.
<Bike>
i think sbcl already incorporates several, so it might be hard to squeeze it much more
Smokitch has quit []
Josh_2 has joined #lisp
<earl-ducaine>
HighMemoryDaemon: A quick export shows that gzip will compress it into a 12M file.
<Bike>
huh... oh wait, maybe gzipping cores was a build option or something.
DonVlad has joined #lisp
<Bike>
yes it is. but also to s-l-a-d.
<Bike>
you give it a number that's just passed to zlib
<earl-ducaine>
HighMemoryDaemon: (sbcl) Presumably the executable has various sparse memorry areas that are simply read into their location when the executable is loaded.
Posterdati has joined #lisp
<HighMemoryDaemon>
aeth: Game development in Lisp sounds particularly interesting.
NotSpooky has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
Kundry_Wag has quit [Remote host closed the connection]
<HighMemoryDaemon>
earl-ducaine: That's cool. With Gzip are you just talking about reducing the download size for the end user or is their a way to actually zip an executable that unzips on launch?
karlosz has quit [Quit: karlosz]
X-Scale has quit [Ping timeout: 240 seconds]
<Bike>
if you use sb-core-compression, i believe it's the latter
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
scymtym has joined #lisp
<HighMemoryDaemon>
earl-ducaine: One thing I'm confused about though is the ":save-lisp-and-die" that is attached to the function name. I'm not so confused as to what it does but what is that syntax feature of Lisp called? I haven't seen that before.
karlosz has joined #lisp
<sjl_>
HighMemoryDaemon: save-lisp-and-die is the name of the function. sb-ext is the package
<HighMemoryDaemon>
sjl_: Thank you.
X-Scale has joined #lisp
<HighMemoryDaemon>
Think channel is super helpful! Glad the Lisp community is like that.
<HighMemoryDaemon>
*This
<sjl_>
you could also (use-package :sb-ext) first, and then just use (save-lisp-and-die ...) but that would import a ton of other stuff you don't need, so usually people just use the package-qualified name for stuff like that.
<HighMemoryDaemon>
Using the "time" command on Linux, I can see that a compiled+gzipped "hello lisp" app takes 0.15s to execute. The compiled+not-compressed "hello lisp" app takes 0.02s to execute.
pierpal has quit [Quit: Poof]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
<sjl_>
right, it takes time to decompress it first. it's a tradeoff between disk space and startup time
<HighMemoryDaemon>
Doesn't affect performance once in un-compresses though, right?
<HighMemoryDaemon>
*once it finishes uncompressing
<sjl_>
right
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
subr has joined #lisp
<scymtym>
there is also the minor difference that multiple SBCL processes cannot share as many memory pages when compression is used
subroot has quit [Ping timeout: 276 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
EvW1 has quit [Ping timeout: 240 seconds]
DingoSaar has quit [Ping timeout: 260 seconds]
saki has joined #lisp
chiyosaki has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
red-dot has joined #lisp
makomo has quit [Ping timeout: 248 seconds]
HighMemoryDaemon has quit [Quit: Leaving]
fikka has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
troydm has joined #lisp
drduck has joined #lisp
<drduck>
Howdy. What's an actively maintained library for common-lisp that's similar to hibernate for java, in that it's an ORM mapping tool?
* jasom
just checked and the readme for integral indeed suggests that it has
mejja has quit [Quit: mejja]
k4rtik has quit [Ping timeout: 265 seconds]
brettgilio has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 240 seconds]
k4rtik has joined #lisp
caltelt_ has joined #lisp
fikka has joined #lisp
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
FreeBirdLjj has joined #lisp
pioneer42 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
caltelt_ has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 268 seconds]
sjl_ has quit [Ping timeout: 276 seconds]
k4rtik has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
EvW has quit [Ping timeout: 276 seconds]
robotoad has quit [Quit: robotoad]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<akkad>
pure drivers can be written in lisp without need to drop to cffi
robotoad has joined #lisp
Kundry_Wag_ has joined #lisp
dyelar has joined #lisp
<drduck>
Is there a good tensorflow binding for common lisp lying around anywhere?
gabiruh has quit [Read error: Connection reset by peer]
gabiruh has joined #lisp
<akkad>
yeah awesome list has many listed
<akkad>
awesome.cl
<aeth>
Any list that lists GCL among its recommendations is so incredibly uncurated that I wouldn't trust anything on it.
<akkad>
aeth: don't hate on what is hip, or awesome
<akkad>
aeth: you're over 30 I take it
<aeth>
Turning 28 next month. I guess I have to stop programming soon.
<akkad>
and it's list gets out of date often, to show you inperfections that it is done by hand.
patlv has joined #lisp
<aeth>
For that list to have gotten out of date and have GCL on it, it would have had to be written in 2005 or so.
<aeth>
I bet someone could get Genera added to the list.
pierre__ has quit [Quit: pierre__]
dyelar has quit [Quit: Leaving.]
Kundry_Wag has quit [Remote host closed the connection]
marvin4 is now known as marvin2
patlv has quit [Ping timeout: 264 seconds]
thelostlambda has quit [Remote host closed the connection]
Kaisyu has joined #lisp
brendyn has joined #lisp
Kundry_Wag_ has quit [Ping timeout: 248 seconds]
patlv has joined #lisp
Guest39745 has quit [Ping timeout: 244 seconds]
cods has quit [Ping timeout: 248 seconds]
Guest39745 has joined #lisp
<jasom>
awesome.cl I believe post-dates GCL not being worth recommending.
<jasom>
We should have a "If you say you are using X on #lisp, we won't laugh you out of the channel" curated list.
cods has joined #lisp
<akkad>
cleavir can resurrect gcl too no?
<aeth>
If you're going to recommend a bunch of things in the same category, you should be opinionated and not just list them alphabetically. e.g. I'd recommend trying SBCL, CCL, and ECL in that order. awesome-cl puts SBCL last because it's alphabetical and ultra-niche ABCL first!
cmatei has quit [Ping timeout: 240 seconds]
brettgilio has joined #lisp
cmatei has joined #lisp
patlv has quit [Ping timeout: 260 seconds]
<akkad>
true
<akkad>
but cl has an image issue, and this goes a long ways to teach potential developers how cool it is