<[rg]>
prompted my search into lisp implementation
<Bike>
acm being real slow today...
<[rg]>
do you like the new website? I don't
<Bike>
i think i like it better than the old website, but that's not saying much.
<beach>
[rg]: I must have missed the context. How is that paper related to Common Lisp?
<[rg]>
at first I thought that CLIST and NLIST where implemented using the same technique for cons cdr and car
<beach>
What is CLIST and NLIST?
<[rg]>
so I came here to find about original implementation details, and how those things work
<Bike>
two linked lists desribed by the paper. at least i think they're linked lists.
<beach>
I see.
<[rg]>
list's maintained by the program that have derivations of a regxp
<Bike>
the program is written in algol 60, so the connection is somewhat tenuous. i doubt this algorithm relies on specific machine details or anything
<Bike>
though it sure has a lot of assembly listings
<Bike>
oh, the program outputs machine code. i see.
<[rg]>
it also relies on CNODE and NNODE routines, which is the most complex part
Kundry_Wag has joined #lisp
ahungry has quit [Ping timeout: 260 seconds]
<Bike>
i'm not familiar with the IBM 7094, so I can't read this very well, but I suspect the "lists" might just be what i'd call arrays. i don't see anything that looks like dynamic memory allocation
Kundry_Wag has quit [Ping timeout: 250 seconds]
<[rg]>
yes I got that feeling as well, it's just weird, how does if find the subroutines? and how did they say where to allocate memory
<[rg]>
oh well, thanks anyways Bike
[rg] has quit [Remote host closed the connection]
<mr_yogurt>
is there an easy way to get the value in a slot with :allocation :class from the class itself? like (some-function (find-class 'my-class) 'my-slot)
<Bike>
not particularly. you can do (slot-value (mop:class-prototype (find-class 'my-class)) 'my-slot), though.
<mr_yogurt>
that works, thank you
buffergn0me has quit [Ping timeout: 265 seconds]
asarch has joined #lisp
Lycurgus has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
gravicappa has joined #lisp
Oladon has quit [Quit: Leaving.]
narimiran has joined #lisp
Bike has quit [Quit: Lost terminal]
narimiran has quit [Client Quit]
Jeanne-Kamikaze has quit [Quit: Leaving]
Oladon has joined #lisp
vlatkoB has joined #lisp
lemoinem has quit [Ping timeout: 256 seconds]
lemoinem has joined #lisp
asarch has quit [Quit: Leaving]
_whitelogger has joined #lisp
splittist has quit [*.net *.split]
liambrown has quit [*.net *.split]
amnesic[m] has quit [*.net *.split]
LdBeth has quit [*.net *.split]
APic has quit [*.net *.split]
eagleflo has quit [*.net *.split]
abbe has quit [*.net *.split]
splittist has joined #lisp
liambrown has joined #lisp
LdBeth has joined #lisp
amnesic[m] has joined #lisp
eagleflo has joined #lisp
abbe has joined #lisp
APic has joined #lisp
orivej has joined #lisp
_paul0 has quit [Remote host closed the connection]
paul0 has joined #lisp
shka_ has joined #lisp
shangul has joined #lisp
Oladon has quit [Quit: Leaving.]
Bourne has joined #lisp
Kundry_Wag has joined #lisp
akoana has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
ATP7 has joined #lisp
pve has joined #lisp
ATP7 has left #lisp ["Leaving"]
<no-defun-allowed>
What do various implementations with threads on multiple processors provide as the return value of GET-INTERNAL-RUN-TIME? I understand that it's implementation dependent, but I'm curious as to how "run time" is interpreted by different people.
retropikzel has joined #lisp
Inline has joined #lisp
<no-defun-allowed>
SBCL interprets it to be the processor time used by all threads as it calls getrusage.
<no-defun-allowed>
Same with Clozure. Perhaps that question had more varied answers in my imagination.
<flip214>
scymtym: yeah, I know about :cache nil. I just wanted a quick test without _any_ caching. Perhaps a esrap:*default-cache* would be nice, so that the ~30 rules don't have to specify that each and every time?
<flip214>
scymtym: and having an optimization level for a library isn't uncommon... it shows confidence ;)
<aeth>
no-defun-allowed: is there a reason to use g-i-run-t over g-i-real-t? I guess g-i-run-t only goes up when computations are going up?
<aeth>
maybe useful for REPL benchmarking...
<splittist>
/me is happy with his new lisp workstation (slime+sbcl rpi4)
<no-defun-allowed>
aeth: That is how I interpret g-i-run-t, yes. However, if I had 12 (24 in your case) threads doing nothing very quickly, then -run- would increment faster than -real-.
torbo has quit [Remote host closed the connection]
Soltex has joined #lisp
<aeth>
yeah, only 24
mikecheck has quit [Quit: quit]
<no-defun-allowed>
splittist: Have you tested threads on the Pi 4? I have meant to get a newer Pi lately, but for whatever reason they're more expensive than I recall.
retropikzel has quit [Quit: Leaving]
<no-defun-allowed>
(What kind of douchebag vendor discontinues the 1GB version and tells people to get the 2GB version? That's more money.)
<aeth>
I still haven't set up my Pi 3 yet
<aeth>
setting up a machine takes time
Soltex has quit [Client Quit]
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
retropikzel has joined #lisp
wxie has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 264 seconds]
hhdave_ is now known as hhdave
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
shifty has quit [Ping timeout: 250 seconds]
shifty has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
<beach>
vms14: There is no particular reason to have a newline after LOOP.
* phoe
makes a quick fix up there, please F5
<vms14>
thanks to both for the hints
<beach>
Sure.
<vms14>
specially for the example, phoe. This way I can't get it wrong :D
<phoe>
CLHS also has an example at 2.4.4.2.5, but it doesn't contain an example for single semi
didi has joined #lisp
<didi>
So TIL `read-char' can be slow even with a string stream.
SGASAU` has joined #lisp
SGASAU` has quit [Client Quit]
heisig has joined #lisp
SGASAU has quit [Ping timeout: 258 seconds]
dddddd has joined #lisp
SGASAU` has joined #lisp
hhdave has quit [Quit: hhdave]
vms14 has quit [Remote host closed the connection]
random-nick has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
SGASAU` has quit [Quit: ERC (IRC client for Emacs 26.3)]
SGASAU has joined #lisp
karlosz has quit [Quit: karlosz]
SGASAU` has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
SGASAU has quit [Ping timeout: 256 seconds]
SGASAU` has quit [Remote host closed the connection]
SGASAU`` has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
SGASAU`` has quit [Remote host closed the connection]
z147 has joined #lisp
gaqwas has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
wxie has quit [Ping timeout: 246 seconds]
random-nick has quit [Quit: quit]
arduo has quit [Ping timeout: 258 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
tutti has joined #lisp
tutti has quit [Ping timeout: 252 seconds]
metallicus has joined #lisp
orivej has joined #lisp
<pjb>
didi: how can it be slow on a string stream? (I assume you mean a character stream opened on a string with with-input-from-string).
<phoe>
didi: do you have any TIME results you'd like to share?
Bike has joined #lisp
izh_ has joined #lisp
retropikzel has quit [Quit: Leaving]
<didi>
Your skepticism helped. SPROF showed >60% of time spent in `read-char', even when running from a in-memory stream. But a simple `read-char' loop was fast. Now I think it's my playing with echo and concatenated streams.
<didi>
I do a lot of those.
keep_learning has quit [Quit: This computer has gone to sleep]
keep_learning has joined #lisp
xlei has quit [Ping timeout: 256 seconds]
xlei has joined #lisp
joshcom has joined #lisp
random-nick has joined #lisp
didi has quit [Read error: Connection reset by peer]
<phoe>
minion: memo for pfdietz: Could you please add a LICENSE to ANSI-TEST? I would like to use some tests from it to test my portable condition system, but I cannot do that without knowing under what terms I can use ANSI-TEST contents.
<minion>
Remembered. I'll tell pfdietz when he/she/it next speaks.
ggole has joined #lisp
metallicus has quit [Quit: Leaving]
izh_ has quit [Remote host closed the connection]
izh_ has joined #lisp
<phoe>
Terminology question.
<phoe>
ASSERT signals a continuable error, because it binds a CONTINUE restart.
<phoe>
CHECK-TYPE does not signal a continuable error, because the restart is named STORE-VALUE.
<phoe>
Is the above correct?
<Bike>
based on the glossary, yeah, seems so
<Bike>
oh, i see, there's the more general "correctable"
<phoe>
ooooh!
<phoe>
That is the term that I was looking for
SGASAU has joined #lisp
<phoe>
the back of my head knew there was a term that looked like "co...able" but the front of it couldn't remember it
<phoe>
Bike: thanks
baz76 has joined #lisp
<Bike>
the page for check-type says its error is "correctable", see
zigpaw5 has quit [Ping timeout: 258 seconds]
<phoe>
yes, I see that now
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
mtzono has joined #lisp
mtzono has quit [Remote host closed the connection]
<Bike>
are you actually doing something like that in an application?
<didi>
Bike: Eeer, no, no... a friend of mine is doing it...
* didi
looks nervous
<Bike>
i wouldn't expect good performance, is all
<didi>
TIL
<Bike>
it looks like in sbcl, each read char will check all the streams in order, so in your example it'll usually find EOFs in a few thousand streams before getting to the actually open one
<Bike>
wait, no, it does alter the streams as it goes
<didi>
My overall idea was giving back to a stream more than a single character. I will think of something else.
<Bike>
like for unread-char? can you not change your algorithms to not need that?
<didi>
Bike: Yes, like `unread-char', but with more characters. I'll try to change it.
<Shinmera>
Bike: something like that is happening in qtools to do dynamic function generation when the function is called.
amerlyq has joined #lisp
<Shinmera>
requires reader hacks to simulate a customisable intern
<Shinmera>
which in turn uses concatenated streams to simulate unreading more than one char.
cylb has joined #lisp
<didi>
It's a good idea, isn't it? I expected the first stream would be dropped as soon as it was exhaust, but I don't think it's happening.
<Bike>
i was wrong, the standard actually requires it's dropped
<Shinmera>
Bike: where do you see that? It says the list /may/ be empty.
<Bike>
"still has to read from"
<Shinmera>
hrm
cylb has quit [Ping timeout: 258 seconds]
<Shinmera>
I wouldn't interpret that as a guarantee.
<Shinmera>
Especially since then it would have to be empty if there's nothing to read from anymore.
<Shinmera>
Rather than just 'may'
joshcom has quit [Ping timeout: 258 seconds]
<amerlyq>
(grunts-of-old) The more I try different prg languages in real-world scenarios on "large enough" projects, the more I wonder why people are NOT using lisp in the first place, as the most natural way to interactively build bridge of abstractions between human perception and hardware details. Oh my... There is so much complexity people keep in their heads only to avoid using Lisp at all costs, even
<amerlyq>
preferring to cripple themselves or reinvent a pitiful semblance of its workflow...
ljavorsk has joined #lisp
joshcom has joined #lisp
<Shinmera>
productivity is hard to estimate, there's practically no trained lispers out there, and a never ending stream of java/c++/js/etc people, lisp has a bad rap, things are done for money first, etc.
<Shinmera>
I could name many reasons but they're all not very interesting and outside our control.
gaqwas has quit [Remote host closed the connection]
<MichaelRaskin>
Building powerful abstractions means that you cannot randomly shuffle people between projects and give them standard-form specs for busywork, as there is more context to absorb before being able to do something useful
<amerlyq>
The problem I face regularly is how language itself influences the mind of people and creates their "boundaries" of thinking, which are obvious from their work. I come long way thinking how "prodigies" differ from regular people, and what exactly keeps me in awe looking at them. And you know, the conclusion I had -- is how much more complexity they keep to themselves over what is visible on the
<baz76>
Any less demanding books than SICP for getting into lisp or it's dialects? Fairly new to programming in general.
<amerlyq>
surface.
ljavorsk has quit [Remote host closed the connection]
<phoe>
baz76: sure
<phoe>
minion: tell baz76 about gentle
<minion>
baz76: please look at gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
<phoe>
if you're new to programming altogether, gentle is the way to go
<phoe>
also, it will teach you the Common Lisp dialect of Lisp
<phoe>
SICP uses Scheme
<baz76>
Thanks. SICP is understandable but I just wanted a break for a day or two from interpreters to just make basic projects like you would in python to learn too. I'll be checking that out.
<phoe>
baz76: you could try Practical Common Lisp if you want small, concrete projects
<baz76>
I'll check that out too.
<phoe>
it's "practical" like that, as in, about 40% of the book is creating simple applications using standard CL functionality
ljavorsk has joined #lisp
<baz76>
Sounds good, I was going to get burned out if all I did was SICP for weeks.
<amerlyq>
Last week I sat near my son, who wanted to create a little (Huge!) game and asked for some help after downloading UnrealEngine. And looking at its interface I felt the dread -- knowing how much of the meticulous project planning process required to convert the evolving idea of "game" or anything into precise actions done in the framework. It has inhumanly large gap in between what you think about and
<amerlyq>
what you actually must do to achieve it. I'm feeling too old for all this complexity and can only eat my hat looking at passionate youth able to do it without thinking, using only intuition.
shifty has joined #lisp
<baz76>
amerlyq game engines are pretty insane in terms of learning curve, might be easier to start with modding. Bethesda's tools are really easy to use and people have made standalone modifications off of it.
<amerlyq>
Yes, game engines are insane :) Still, what I realized by combining all my experiences, is that every game and every program has a "story" to convey to the player and interact with -- not the narrative or lore, or life of main character, but the "story" of design, art, struggles, pains and inspirations of the developer, his ups and downs, his life experiences. And developing it through exploratory
<amerlyq>
programming is also some kind of a "story" of human growth and dreams -- the "story" which developer lives in and interacts with. Yes, it seems stories are the greatest asset of humans to pass experiences around, even if not expressed in a conventional media.
dddddd_ has joined #lisp
cylb has joined #lisp
grant_ has joined #lisp
grant_ is now known as [rg]
<[rg]>
Bike: did you implement the ken thompson construction in lisp?
dddddd has quit [Ping timeout: 264 seconds]
<Bike>
i've implemented regexes as DFAs, at least
<Bike>
i couldn't tell you if that's what he was doing
<amerlyq>
So, the point is... Lisp allows you to write your "story" directly from any high or low level, following your inspiration, and then add more juicy details to whatever you wish to elaborate or generalize, immediately looking at results at hand. It's almost like writing prose in natural language or sculpting the figurine: flexible narrative but with semantic strictness of the relationships. It requires
<amerlyq>
the same story-writing abilities as demanded from game designers, movie producers or authors, but expressed directly in the language body itself instead of on separate piece of the paper with project plans and designs. So... that leads to the initial question -- why using anything beside the Lisp if any other language can't express the "story" even near as smoothly?
<[rg]>
he seems to not worry about that since he manages to check all possible states
<[rg]>
amerlyq: was that a response to me?
<amerlyq>
[rg]: nope, you connected in-between :)
<Bike>
i had something to interpret the nfa directly too, i think
<[rg]>
I asked a question like it a few days ago :P
<Bike>
so i could follow what was going on
<[rg]>
I get the feeling you could do this construction and create lisp output
<[rg]>
as lambdas or something
<Bike>
well that's what i did, yeah. i wasn't outputting 7094 assembly.
joshcom has quit [Ping timeout: 256 seconds]
<[rg]>
amerlyq: I suspect game devs don't like gc
<[rg]>
;)
<pjb>
That's because they don't know real time gc…
<[rg]>
that's a thing?
<amerlyq>
pjb: +1, that's a thing?
<pjb>
Yes.
<pjb>
Also, parallel gc, incremental gc, etc…
<[rg]>
my prof always tells the mit story about the robot and baseball
<[rg]>
it basically missed the ball due to gc in lisp at the time
<Bike>
the garbage collector is not part of the language definition at all.
<[rg]>
Bike: gee, thanks
<[rg]>
oh really
<[rg]>
so what does it look like if you don't have one
<[rg]>
does any lisp do this?
<Bike>
probably not. it would kind of suck.
<Bike>
presumably after a while your CONS calls would start signaling out of memory errors.
<Bike>
but what i mean is that the language defines no interface to the gc at all, let alone something as complex as using a different gc.
<amerlyq>
and I hoped pjb mentioning "real time gc" hinted on some already existing reimplementation for lisp...
[rg] has quit [Quit: [rg]]
[rg] has joined #lisp
omar has joined #lisp
<pjb>
amerlyq: the hint is: take your favorite implementation, and put a f.....g real-time gc in it!
<pjb>
then you will be able to sell it to game programmers.
<Bike>
in this example a*|bcd means like a[bc]*d, by the way. i didn't bother writing a PCRE parser
<amerlyq>
pjb, so always, everything in the world is mostly DIY, isn't it? :D
<pjb>
Exactly.
<pjb>
Take inspiration from Elon Musk!
<amerlyq>
Great demotivating example
[rg] has quit [Read error: Connection reset by peer]
[rg] has joined #lisp
<pjb>
He wanted to go to Mars, just millions of people. But HE took the steps to do it, instead if taking excuses (such as booo, the NASA doesn't want me as astronaut or such). He made paypal to make money, he made tesla to make solar panes and batteries, he made the boring company to make a submartian base, he made SpaceX to make his own rockets, and so on!
<pjb>
s/just millions/just like millions/ s/instead if/instead of/
z147_ has joined #lisp
<[rg]>
Bike: yeah that's fine, I'm personally only familiar with posix regex
<amerlyq>
I called the example "demotivating" considering the aspirations are greatly differing between the people. It very important how you define your immediate happiness, being it "I want to revel in exploratory programming" .vs. "I want to build and manage organization to achieve my goals". I'm not sure switching between these viewpoints without change of the heart will deem anything good.
omar has quit [Remote host closed the connection]
<pjb>
amerlyq: you can always try to make other people do your thing. It usually costs a lot of money or a lot of blood…
z147 has quit [Ping timeout: 240 seconds]
<Bike>
you should pretty much be able to figure out the dfa from the tagbody. it's start -a> 0, start -/> fail, 0 -> 2, 2 -d> success, 2 -/> 3, 3 -b> 0, 3 -c> 0, 3 -/> fail. 0/2 are redundant but oh well
<pjb>
programming, from newbie to boss: 10 print 'hello' -> Hey Mark, I want a program to great me!
<MichaelRaskin>
You often cannot make other people make your thing well, though
<amerlyq>
You often cannot make other people make even their thing well
dddddd_ is now known as dddddd
<amerlyq>
And it's a shame to acknowledge, but you often cannot make even your thing well
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
<amerlyq>
pjb: yep, it sucks. So you are still forced to "build and manage organization" to earn a lot of money, to spent on somebody to do things you want, so you could "revel in exploratory programming". Kind of roundabout way to make your even life harder and less satisfactory, when your real goal and means to achieve the goal hinder each other.
akoana has quit [Ping timeout: 264 seconds]
cylb has joined #lisp
[rg] has quit [Ping timeout: 265 seconds]
<amerlyq>
Whatever, I could sit and write gc instead of grumbling here -- such change of the pace is nice too.
<pjb>
amerlyq: you should also take into account the fact that anything to do, is to actually compete sexually.
<pjb>
Elon Musk included. See how he names his things.
<amerlyq>
Isn't it another groundless conspiracy theory, because people think accidental facts are less probable than they actually are?
SGASAU has quit [Remote host closed the connection]
<baz76>
pjb pursuit of status is only the result of sexual competition, it's why technological progress doesn't actually make people happier
<baz76>
but best to leave that discussion elsewhere i think
SGASAU has joined #lisp
<amerlyq>
Back on topic: Do you know about any "disillusionment" articles from someone who started big project in Lisp and then concluded Lisp is not fit for the work? Such experiences can provide invaluable insights in the actual limitations to overcome (or abandon Lisp too). Remember main aspiration from the above was "strive to write a story in the natural way... which can _accidentally_ become interactive
<amerlyq>
game".
<amerlyq>
* for the job
baz76 has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 264 seconds]
shukryzablah has joined #lisp
<pjb>
amerlyq: there are not a lot of them.
<shukryzablah>
what's the irc channel for lisp in general
<pjb>
amerlyq: there's redit that has been rewritten from lisp, but the postmorterm wasn't that negative on lisp IMO.
<amerlyq>
selwyn: thanks for link, it seems the last postmortem I read about Lisp deficiencies is already 18 years old: "Postmortem: Naughty Dog's Jak and Daxter: the Precursor Legacy"
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 258 seconds]
X-Scale` is now known as X-Scale
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
pilne_ has joined #lisp
pilne has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
<lukego>
amerlyq: I've had a few disillusionments with lisp/scheme. Sometimes it's just that Lisp is great for writing a prototype and once that works it makes sense to port to another language. other times it's that some specific requirement is harder with Lisp e.g. having a lightweight runtime system with low latency. *shrug* every language/system has its strengths and weaknesses
iAmDecim has joined #lisp
gaqwas has quit [Remote host closed the connection]
<phoe>
amerlyq: this is only partially on topic, but I can give you a rant about how hardcore Lisp evangelists like Graham contribute to the bad vibe that Lisp-as-a-language has around the world.
cosimone has joined #lisp
<amerlyq>
lukego: I talked above in lengths about "writing game story" in Lisp with focus on "human-oriented language". Of course, when you optimize for hardware, you usually pick something appropriate for hardware.
<Bike>
i'll post this here too - i'm writing up a hypothetical language extension for concurrency, focusing on atomics since bordeaux threads already exists. i'd appreciate comments. https://gist.github.com/Bike/a89cbfda64ace273b12eed8675dda632
<shka_>
Bike: !!! What a splendid idea!
ayuce has joined #lisp
<shka_>
I will read it carefully but the idea itself is exactly what I would want to see in the CL.
rand_t has joined #lisp
<amerlyq>
By the way, considering you can dump/load lisp image with all the state preserved -- how much of it impossible for opengl? It seems on restore it must reinitialize GPU and send everything again to be working. What has such problems beside opengl?
<phoe>
amerlyq: all foreign libraries must be closed/reopened on image freezing/thawing. Of course, it's a non-issue if you don't use FFI.
<phoe>
But, basically, when you freeze your image, you need to close all stuff that is invalidated by the freeze/thaw operation. And then the thawed image must reopen/reallocate/redo/reeverything all of these.
<phoe>
Same thing as with e.g. files.
<phoe>
Bike: as for the last part, wouldn't it be more beneficial to state semantics for DEFINE-MODIFY-MACRO itself rather than list some examples of DEFINE-MODIFY-MACRO-created macros?
<Bike>
the d-m-m semantics are defined by the part of the description of "atomic" that says read-modify-write operations on an atomic place are atomic. logandf and stuff are there for machines where those particular r-m-w operations can be done with special machine support.
<phoe>
now that I think about it, it wouldn't really be easy - either DEFINE-MODIFY-MACRO would need to recognize which functions can be called wait-free or we would need to predefine some known subset of modify macros that *we* know to be wait-free
<Bike>
read modify write is definitely the part i'm least sure about, though.
<phoe>
yes, that's what I'm thinking
iAmDecim has quit [Ping timeout: 250 seconds]
<phoe>
but it's kind of weird for me to imagine #+amd64 (define-modify-macro logandf ...)
<phoe>
unless there's a slower fallback implementation for platforms that do not support fast wait-free logand
cosimone has quit [Remote host closed the connection]
<phoe>
I guess that everything can fall back on locks if it cannot be implemented better; it's a slow but safe fallback
cosimone has joined #lisp
devrtz has quit [Ping timeout: 240 seconds]
devrtz has joined #lisp
jmercouris has joined #lisp
gabiruh_ has joined #lisp
<jmercouris>
anyone know of something like Deploy, that also packages a CL program for various Linux distributions?
<minion>
jmercouris, memo from phoe: one curious option about plists for slots is that they are not really plists. :reader/:writer/:accessor can be specified multiple times and *ALL* occurrences of these are used for creating functions.
<minion>
jmercouris, memo from phoe: they certainly look like plists, and they pretty much may formally be plists, but they are parsed differently than via the standard GETF function that's usually used for dealing with plists.
gabiruh has quit [Ping timeout: 256 seconds]
<jmercouris>
phoe: so in that case, it is definitely wise to make sure that :accessor is not duplicated!
<Bike>
actually, shower thought, the atomic rmw thing is bad since with the implicitly atomic places it means an implementation has to ensure (incf (svref ...)) is atomic even when the user doesn't care, which is probably frequent
<jmercouris>
in any case, you saw that in the end I went ahead and just extended the class without using moptilities to populate the slot with forms from the parent class
<Bike>
phoe: the intent is that logandf can be used so the implementation can _maybe_ do it wait-free. it's not required to do so, so it could fall back to a cas loop or something.
<jmercouris>
of if there is nothing like Deploy, anyone know a good way to get a program packaged for multiple Linux distributions with as little friction as possible?
tutti has joined #lisp
Kundry_Wag has joined #lisp
<Bike>
phoe: this is also the case since e.g. it's very unlikely an implementation could do logandf on bignums in any easy way
axion_ has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
cosimone_ has joined #lisp
axion_ has quit [Client Quit]
jmercouris has quit [Remote host closed the connection]
iAmDecim has joined #lisp
cosimone_ is now known as cosimone
frgo has quit [Ping timeout: 272 seconds]
frgo has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
<phoe>
minion: memo for jmercouris: flatpak, appimage.
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
Lycurgus has joined #lisp
EvW has joined #lisp
<Bike>
actually if the implicit atomicity is unordered the rmw thing doesn't matter so much, i guess
<jcowan>
There was a Lisp machine (maybe not *the* Lisp Machine) that for a long time had no GC, because you typically crashed before running out of memory.
<Bike>
was it commonly mounted on missiles
<jcowan>
No, I just think this was before the idea that programs could be expected to run forever (i.e. servers)
<jcowan>
I've written many C programs that don't bother to properly free storage, because they are going to die long before they eat up even a measly megabyte.
<jackdaniel>
such approach pains my sense of aesthetics
axion has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<jcowan>
The way I see it, in C the heap belongs to the programmer, not the implementation as in most languages (even C++). You get to use it any way you like, and malloc/free is just one approach, not necessarily optimal for your program. You can call sbrk() yourself and get however much memory as a big honking chunk, and then do whatever you want.
ljavorsk has quit [Ping timeout: 250 seconds]
<Josh_2>
petition to change the name of anonymous functions to phantom functions
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
Lycurgus has quit [Quit: Exeunt]
tutti has joined #lisp
shangul has quit [Read error: Connection reset by peer]
<amerlyq>
Aurora_v_kosmose: on surface you are right, but somebody must decide how the money are maid exactly and for what exactly they are paid. Therefore pjb is also not wrong attributing everything to Elon Musk.
shangul has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
zooey has joined #lisp
iAmDecim has joined #lisp
aamukastemato has joined #lisp
vmhost has joined #lisp
dddddd has quit [Ping timeout: 240 seconds]
<phoe>
jeosol: nice
joshcom has quit [Ping timeout: 250 seconds]
tutti has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: Terminated!]
karlosz has joined #lisp
<Aurora_v_kosmose>
amerlyq: Such enterprises also require initial funds most people don't have.
<Aurora_v_kosmose>
(Funds which he did have)
<Bike>
please stop talking about elon musk in the lisp channel.
<Aurora_v_kosmose>
k
<Shinmera>
Aurora_v_kosmose: amerlyq: this is not the channel for this.
<amerlyq>
Shinmera: sorry, I know, it was simply follow up
<Aurora_v_kosmose>
It was indeed continuation of earlier offtopic.
<Shinmera>
I don't care, just stop it.
TwoNotes has quit [Quit: Leaving]
<Aurora_v_kosmose>
We kinda did on first notice.
renzhi has joined #lisp
<jeosol>
phoe: thanks for the info from reddit
<phoe>
jeosol: no problemn
<phoe>
ANSI-TEST is a really nice thing
<phoe>
I've run like 8% of all condition-system-related tests so far and already found six bugs in my implementation
<jeosol>
phoe: was the rest of that for me, or a previous discussion here?
<phoe>
it's completely unrelated
<jeosol>
oh ok
<jeosol>
I noticed something in my recent updates of SBCL, not sure maybe it was always there. If I am coding and changing things back and forth, e.g., using aref for list, I get warnings, which is nice and appropriating linting of the codes
<jeosol>
Also using various suggestions you have guys have given in the past, code is more stable now, normally my longer runs (2-3 weeks) don't hiccup at all.
Kundry_Wag has joined #lisp
<jeosol>
merci
bars0 has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
cosimone has joined #lisp
hiroaki has quit [Ping timeout: 265 seconds]
iAmDecim has quit [Ping timeout: 265 seconds]
grant_ has joined #lisp
hiroaki has joined #lisp
shangul has quit [Ping timeout: 265 seconds]
SGASAU has quit [Remote host closed the connection]
asarch has joined #lisp
SGASAU has joined #lisp
shifty has joined #lisp
hiroaki has quit [Ping timeout: 258 seconds]
Kundry_Wag has joined #lisp
heisig has quit [Quit: Leaving]
emys has joined #lisp
<emys>
hi, how can I find out the recipe used for a package?
<Bike>
What do you mean by recipe?
<emys>
let's say i am interested in how `python-isort' was built
<emys>
I would assume that there is a corresponding guix.scm to that package
<Bike>
Is that an emacs library? you may be in the wrong channel, this place is for Common Lisp.
<emys>
oh I am sorry, you are right, wrong channel
<Bike>
no worries.
<ayuce>
i wonder which channel was targeted though.
<Aurora_v_kosmose>
#guix
<Aurora_v_kosmose>
It's a scheme-based (guile) reproducible source-based package manager.
Intensity has quit [Read error: Connection reset by peer]
GuerrillaMonkey has quit [Remote host closed the connection]
GuerrillaMonkey has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 265 seconds]
iAmDecim has quit [Ping timeout: 256 seconds]
GuerrillaMonkey has quit [Quit: Leaving]
Jeanne-Kamikaze has joined #lisp
shukryzablah has quit [Quit: ERC (IRC client for Emacs 27.0.90)]
pve has quit [Quit: leaving]
ggole has quit [Quit: Leaving]
aamukastemato has quit [Quit: Leaving]
torbo has joined #lisp
iAmDecim has joined #lisp
<jcowan>
Apple's enforcement policy is very inconsistent anyway. It seems clear that you can download resources like new levels, and in an interpreted environment, code is just another resource.
mn3m has joined #lisp
cosimone has quit [Quit: Quit.]
keep_learning has joined #lisp
iAmDecim has quit [Ping timeout: 260 seconds]
iAmDecim has joined #lisp
lxbarbosa has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
<phoe>
news: portable-condition-system now successfully passes the ANSI-TEST tests related to the condition system
<phoe>
may everyone who ever contributed to ANSI-TEST be happy and live a merry and peaceful life
dale has joined #lisp
keep_learning has quit [Quit: This computer has gone to sleep]
gravicappa has quit [Ping timeout: 260 seconds]
cosimone has joined #lisp
iAmDecim has joined #lisp
<jackdaniel>
phoe: I've linked a CL repl, so
<samlamamma>
phoe:Is the goal to merge it with SICL?
<phoe>
jackdaniel: linked? sorry, I'm tired and didn't understand what you mean
<phoe>
samlamamma: that is a possibility, yes
<jackdaniel>
phoe: I've pasted a link to eql5 for iphone/ipad which has cl repl, then you say that "cl repl might happen" on these platforms
<jackdaniel>
so I don't understand your comment
<phoe>
jackdaniel: wait, on the app store?
iAmDecim has quit [Ping timeout: 265 seconds]
* jackdaniel
urges phoe to click on the link before commenting. no, on the testflight
lalilulelo has joined #lisp
<phoe>
what I meant is that there are applications already 100% published on the app store that implement language REPLs/compilers
<phoe>
s/might happen/might get 100% appstore-published/
<jackdaniel>
to my knowledge it is forbidden to publish there applications which produce native code
<samlamamma>
phoe: jackdaniel: Sorry for butting in: This whole conversation sounds like you two agreeing with each other
<phoe>
jackdaniel: it was the case for a long time
<phoe>
but recently Apple has changed its stance on compilers on App Store
<jackdaniel>
uhm
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 250 seconds]
<phoe>
so it might be possible to publish this officially
renzhi has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<phoe>
I mean, toy lisp REPLs are already there - https://apps.apple.com/us/app/my-lisp/id1245341806 - dunno if they generate any native code there since it seems to be just an interpreter, but there are C++ compilers there that pretty surely compile down to assembly
<phoe>
so future looks bright for that project you linked :D
mrcom has quit [Ping timeout: 265 seconds]
shifty has quit [Ping timeout: 265 seconds]
iAmDecim has joined #lisp
shifty has joined #lisp
cosimone has quit [Quit: Quit.]
dddddd has joined #lisp
z147_ has quit [Remote host closed the connection]
z147_ has joined #lisp
KDr22 has quit [Ping timeout: 258 seconds]
man213 has quit [Ping timeout: 265 seconds]
KDr22 has joined #lisp
nwoob has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<nwoob>
is there some article I can read that shows some basic understanding in how cl oop is different from that of languages like java,c#?
<jackdaniel>
minion: tell nwoob about pcl
<minion>
nwoob: please see pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<nwoob>
I need to read the whole book to understand the answer to my question?
<phoe>
nwoob: tl;dr methods belong to generic functions, not to classes
<phoe>
and the object system is programmable, so you can define what it means to e.g. access a class slot
<jackdaniel>
you can skim the table of contents at least
<jackdaniel>
reading chapter 16. and 17. may be a good introduction
<jackdaniel>
(and you may treat examples as some esoteric pseudocode with parenthesis :)
<phoe>
also you can combine methods and their results in arbitrary ways thanks to CL method combinations
<phoe>
also you have basics aspect-oriented programming by default thanks to the default method combination and its :BEFORE/:AFTER/:AROUND methods
<phoe>
s/basics/basic
<phoe>
also CHANGE-CLASS is a thing, allowing you to change an object's class at runtime if you ever *really* need it
jason_m has quit [Remote host closed the connection]
<phoe>
also parts of the object system are themselves programmable, such as the generalized constructor duo called MAKE-INSTANCE + INITIALIZE-INSTANCE or the generalized printer called PRINT-OBJECT or even more details inside the so-called metaobjet protocol
hugbubby has joined #lisp
<phoe>
also multiple inheritance that's *pleasant* to use when compared to java/c# interfaces and c++ virtual inheritance
<phoe>
these are the most notable/useful differences that I can remember right now
lalilulelo has quit [Quit: Leaving]
<jackdaniel>
I think it is hard to communicate when many people talk at the same time, so I'm going to sleep.
<phoe>
just two of us talking at once
<nwoob>
whaaat? change the class of object at runtime? first time heard of something like that... but i also have very less exp with programming so
<nwoob>
anyway I'll start with the book, first i'll complete CL:gentle inroduction
Kundry_Wag has joined #lisp
<jcowan>
CL MI cleverly avoids the pitfalls of "mainstream" MI by not trying to do to much and by working with generic functions, the best thing about OO.
Kundry_Wag has quit [Remote host closed the connection]
<phoe>
MI?
Kundry_Wag has joined #lisp
<no-defun-allowed>
multiple inheritance?
<phoe>
oh right, thanks
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 240 seconds]
iAmDecim has quit [Ping timeout: 264 seconds]
grant_ has joined #lisp
grant_ is now known as [rg]
emys has quit [Quit: Leaving]
hhdave has joined #lisp
nwoob has quit [Ping timeout: 265 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
SlashLife has quit [Quit: Baking more cake ...]
keep_learning has joined #lisp
SlashLife has joined #lisp
mrcom has joined #lisp
kdark has joined #lisp
random-nick has quit [Quit: quit]
iAmDecim has joined #lisp
Bourne has quit [Ping timeout: 265 seconds]
[rg] has quit [Ping timeout: 256 seconds]
Grap3s0da has joined #lisp
renzhi has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Grap3s0da has quit [Read error: Connection reset by peer]
kdark has quit [Remote host closed the connection]
kdark has joined #lisp
Kundry_Wag has joined #lisp
terpri has joined #lisp
ayuce has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
wxie has joined #lisp
Inline has quit [Quit: Leaving]
Oladon has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]