<beach>
sm2n: Oh, you want to know the call sites?
<beach>
That would be implementation specific.
<beach>
And the system is not required to keep such information, which is fortunate, or else we would not have any commercial Common Lisp vendors.
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
theothor` has quit [Ping timeout: 268 seconds]
gioyik_ has joined #lisp
gioyik has quit [Ping timeout: 240 seconds]
theothor` has joined #lisp
theothor` has quit [Ping timeout: 246 seconds]
heisig has quit [Ping timeout: 265 seconds]
wxie has joined #lisp
theothor` has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
theothor` has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 240 seconds]
theothor` has joined #lisp
theothor` has quit [Ping timeout: 260 seconds]
indathrone has joined #lisp
indathrone has quit [Remote host closed the connection]
Lord_of_Life has joined #lisp
<White_Flame>
sm2n: I was going to say maybe you could try a heap walker, but those symbol references would exist embedded in machine code as well (probably mostly PC-relative data & closure slots), which might be even harder to introspect
<White_Flame>
but the GC would need to know they're there, too
<White_Flame>
and while you could detect the reference in a function to a symbol, as beach said the debug info linking that back to sexpr form usage wouldn't be guaranteed to be there anyway. Function-object level would be the most granular you could get
orivej has joined #lisp
theothor` has joined #lisp
aindilis has joined #lisp
aindilis has quit [Remote host closed the connection]
Sheilong has quit [Quit: Connection closed for inactivity]
theothor` has quit [Ping timeout: 260 seconds]
vegai has joined #lisp
aindilis has joined #lisp
cchristiansen has joined #lisp
cchristiansen has quit [Remote host closed the connection]
indathrone has joined #lisp
theothor` has joined #lisp
narimiran has joined #lisp
theothor` has quit [Ping timeout: 240 seconds]
hiroaki has quit [Ping timeout: 246 seconds]
theothor` has joined #lisp
imuo has quit [Ping timeout: 240 seconds]
theothor` has quit [Ping timeout: 246 seconds]
hiroaki has joined #lisp
GreaseMonkey has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 240 seconds]
theothor` has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
<puchacz>
using with-lock-predicate/wait which gets expanded to https://en.wikipedia.org/wiki/Double-checked_locking - so it checks if there is a worker waiting before acquiring a lock, and if there is, it grabs a lock and checks again
<puchacz>
is it actually correct? the first check may incorrectly show that there is no worker waiting
vegansbane6963 has joined #lisp
zdravko61 has quit [Ping timeout: 246 seconds]
<puchacz>
there is a notify-count as well, updated only within a locked block, maybe it helps:) ?
<puchacz>
right, wait-count uses atomic counter, e.g. sb-ext:atomic-decf
<puchacz>
all good
<puchacz>
(I think)
zdravko61 has joined #lisp
<puchacz>
but then why it checks the condition inside the lock block again?
<puchacz>
before sending notify
luni has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
luni has quit [Ping timeout: 246 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
contrapunctus has joined #lisp
rogersm has joined #lisp
<beach>
jmercouris: I have no objection to that.
wxie has quit [Ping timeout: 252 seconds]
<sm2n>
beach, White_Flame: thanks
<sm2n>
function level is sufficient for what I want, I don't need the exact callsites
<beach>
Oh, then that's easy.
<beach>
Just use do-all-symbols and check whether the symbol and `(setf ,the-symbol) are FBOUND.
<sm2n>
err, maybe it will be better if I explain what I am trying to do
<beach>
Go ahead.
<sm2n>
I want to build a dependency graph of functions loaded in the current image
<beach>
I see. That's a bit harder.
<beach>
Some implementations have a WHO-CALLS function.
<beach>
And I think SLIME uses it if it exists.
<sm2n>
oh, this looks good. thanks!
luna_is_here has quit [Ping timeout: 258 seconds]
<beach>
SB-INTROSPECT:WHO-CALLS for SBCL.
<sm2n>
yup I found it
luna_is_here has joined #lisp
luna_is_here has quit [Read error: Connection reset by peer]
luna_is_here has joined #lisp
puchacz has quit [Quit: Connection closed]
hendursaga has quit [Ping timeout: 240 seconds]
luni has joined #lisp
hendursaga has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
luna_is_here has quit [Ping timeout: 276 seconds]
luna_is_here has joined #lisp
luni has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
luni has joined #lisp
luna_is_here has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
luna_is_here has joined #lisp
zdravko61 has quit [Remote host closed the connection]
zdravko61 has joined #lisp
OlCe has quit [Ping timeout: 240 seconds]
luna_is_here has quit [Ping timeout: 246 seconds]
luna_is_here has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
<beach>
My question was more about which one of us agrees to do it.
<Bike>
oh, sorry.
<jmercouris>
I can do it
sp41 has joined #lisp
<beach>
OK, sounds good.
<jmercouris>
I'll also make a request for Nyxt, so it should be faster to batch
<beach>
I agree.
motersen has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
motersen has joined #lisp
luna_is_here has quit [Ping timeout: 265 seconds]
motersen has quit [Client Quit]
aartaka_d has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
motersen has joined #lisp
motersen has quit [Client Quit]
__jrjsmrtn__ has joined #lisp
luna_is_here has joined #lisp
_jrjsmrtn has quit [Ping timeout: 240 seconds]
motersen has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
luna_is_here has quit [Read error: Connection reset by peer]
luna_is_here has joined #lisp
motersen has quit [Client Quit]
* jcowan
discovers that "Lisp image" does not mean what he thought it meant.
<jcowan>
first because it is dynamic, and second because it is characterized by a global object space.
<beach>
What did you think it meant before, and what do you think it means now?
luni has quit [Ping timeout: 240 seconds]
<jcowan>
I took it to be closely analogous to "Smalltalk image" or "Interlisp sysout"; that is, a static representation of a running process.
<beach>
As saved on secondary memory, say?
<jcowan>
Just so.
<beach>
I see.
Sheilong has joined #lisp
motersen has joined #lisp
* beach
thinks it could also mean the perception of Lisp in people's minds.
<jcowan>
new gears are meeting in my brain with a loud CRUNCH
<beach>
I know the feeling.
<jcowan>
Oh, sure, in the sense 'the image of Lisp'
<beach>
Yes.
<jcowan>
slow, interpreted, obsolete, etc.
<beach>
Exactly!
motersen has quit [Client Quit]
<jcowan>
On the second point, it is a very interesting formal characteristic and much wider than Lisp, the idea of a fully shared object space
<Xach>
a miracle tool that will make you better than all those averages (people of average intelligence who do not use lisp)
<jcowan>
"Better" makes me itch. I'd rather say "more efficient at certain activities".
<beach>
What would be an example of an object space that is not fully shared? Unix?
<Xach>
jcowan: incorrect. learning lisp will make you better than other people. and richer.
<Xach>
this is clearly explained in The Blub Paradox.
<jcowan>
Or else it won't.
<beach>
Heh.
<jcowan>
That was my father's universal answer to all dogmatisms.
heisig has quit [Quit: Leaving]
<jcowan>
(he was a legal philosopher by training)
luna_is_here has quit [Ping timeout: 246 seconds]
warweasle has joined #lisp
wsinatra has joined #lisp
luna_is_here has joined #lisp
kslt1 has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
luna_is_here has quit [Read error: Connection reset by peer]
astronavt has joined #lisp
luna_is_here has joined #lisp
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
<Odin->
Where does the "Lisp in interpreted" bit come from?
<Odin->
s/in/is/;
<mfiano>
It is a common misconception.
orivej has joined #lisp
<beach>
People tend to associate "compilation" with batch processing where an executable file is created, and "interpretation" with interactive work.
motersen has joined #lisp
<beach>
... and since most programmers seem to have very skimpy training when it comes to how programming languages are processed, they don't see other possibilities.
<beach>
It doesn't help that more widely used programming systems such a Python are both interactive and slow.
motersen has quit [Client Quit]
<Odin->
Quite.
motersen has joined #lisp
motersen has quit [Client Quit]
freshmaker666 is now known as greeb
<Odin->
It just seems odd, given that Lisp has had compilers since essentially the very start.
yonkunas has joined #lisp
<Odin->
But it does seem hard for many people to grasp that a single system can do both.
<Xach>
Personally speaking, I did not really understand what "compile" meant before encountering Common Lisp.
<Xach>
The DISASSEMBLE function helped me understand a little better that an interactive compiled thing was possible.
<Odin->
Probably the same for me, though I remember reading a fair bit about how it isn't just one or the other in connection with Perl's processing model.
<beach>
Xach: So you did not take a "compilation" course?
<aeth>
Mentioned in 1994 and fully outlined in 1998, so Common Lisp was already published by then.
<aeth>
This kind of thinking is implicit in the design of Unix, though... where you paired shell with C.
<aeth>
And most popular programming languages come from the Unix world.
<Xach>
beach: I did not.
<Odin->
And the ones that don't are treated as either curiosities (Lisp, Fortran) or silly things we've developed past (COBOL, BASIC). Funny that.
skapata has joined #lisp
skapata has quit [Remote host closed the connection]
waleee-cl has joined #lisp
<beach>
Xach: I see.
wsinatra_ has joined #lisp
wsinatra has quit [Read error: Connection reset by peer]
IPmonger has joined #lisp
rumbler31 has joined #lisp
tiwEllien has joined #lisp
<kevingal>
How do you leave a message for someone with the minion?
<jackdaniel>
minion: memo for kevingal: bla bla
<minion>
Remembered. I'll tell kevingal when he/she/it next speaks.
<kevingal>
Thank you!
<minion>
kevingal, memo from jackdaniel: bla bla
<jackdaniel>
sure
luni has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<jcowan>
Of course, essentially all code is in Cobol.
<jcowan>
The original Dartmouth Basic was a compiler; I think the idea that all REPL-ish development systems are interpreters was a result of the microcomputer bottleneck.
dilated_dinosaur has quit [Read error: Connection reset by peer]
dilated_dinosaur has joined #lisp
luni has quit [Quit: Connection closed]
<jcowan>
bytecode is normally much more compact than native code on such systems.
luni has joined #lisp
motersen has joined #lisp
<fitzsim>
hi jcowan
<fitzsim>
jcowan: last week you were asking about a HOWTO for Common Lisp scripting that minimizes boilerplate
<fitzsim>
I happened to be working on it for fun, and seeing someone else wanting the same thing, I decided to publish it
<fitzsim>
jcowan: it's an actual working script, rather than a HOWTO
<fitzsim>
I'm hoping you can paste the clone && run one-liner and it'll work for you, if you already have your operating system's SBCL or CLISP installed
Demosthe1ex has joined #lisp
<srandon111>
hello all, can somebody explain to me why by default lisp is case insensitive for functions ?
<jcowan>
I do, no worries there
<srandon111>
and if something you do genrally change as setting ?
<beach>
srandon111: Lisp is not case insensitive.
Demosthenex has quit [Ping timeout: 245 seconds]
<jcowan>
srandon111: BECAUSE LISP GOES BACK TO THE TIME WHEN COMPUTERS OFTEN COULDN'T DO LOWER CASE.
<beach>
srandon111: And it has nothing to do with functions. It has to do with how the reader creates symbols.
<jackdaniel>
some people change it the readtable case, but that's not common
<jackdaniel>
if you care about how symbols are printed, just (setf *print-case* :downcase) in the repl
<jcowan>
beach: multiplex negatio farblondiet: you got one too many negations there.
<beach>
Ouch.
<jackdaniel>
srandon111: i.e you could set the readtable case to :preserve, but that's not a good idea
<beach>
srandon111: And, as I often explain, it is usually pretty pointless to ask "why" Lisp is the way it is, because the explanation is often just historical.
<jackdaniel>
because then you'd need to use lisp functions like (LIST (CAR foo))
<jcowan>
It's an extremely common performance error: our poor monkey brains don't seem to be good at how many negations there are in a sentence.
<beach>
jcowan: It would be an exaggeration to say that I am not unhungry now.
<jcowan>
"I don't want you to think I'm not incoherent."
<jcowan>
In the end all explanations are historical, and it seemed to me that srandon111 was asking for one: "Why is this the default?"
<jcowan>
Biologists say: "Everything is the way it is because it *got* that way."
<beach>
Probably again for historical reasons.
<phoe>
biology is 100% historical reasons
<phoe>
"it used to work in the past, if it still works then it means that the folks who got this the first time reproduced well enough"
<jcowan>
Which is true of any evolved system, emphatically including Lisp.
luni has quit [Quit: Connection closed]
<phoe>
"...or that there were no meteorites hitting Earth along the way yanno"
* jcowan
nods
<phoe>
conscious evolution of software systems is a little bit better than blind evolution because we can actually anticipate meteors and program defensively around them
<phoe>
so if we're lucky our Lisp programs may survive longer than us in case of another cataclysmic event
<jcowan>
There's a tendency for people outside the CL community to look at the 1500+ pages of weirdness and think "Oh, this is a research system where everything and the kitchen sink was put in because why not."
<jcowan>
And then (being in the grip of Geek Explainer Syndrome) I have to explain that no, everything is there because it once served a severely practical purpose. Except the Roman numerals.
<fitzsim>
haha
<fitzsim>
Roman numerals were added just for fun
<fitzsim>
for me, reading Cltl was great for understanding why everything was added
<Nilby>
Roman numeral printing is quite practical for hierarchical list numbering.
hiroaki has quit [Ping timeout: 246 seconds]
<jcowan>
True, provided the numbers don't get too big.
<fitzsim>
yeah, there's a note about that (just checked)
<fitzsim>
"nearly all implementations produce Roman numerals only for integers in the range 1 to 3999, inclusive."
<fitzsim>
some fancy ones could do up to 4999 though
Demosthe1ex is now known as Demosthenex
<phoe>
(format nil "~@R" 4000)
<phoe>
hmmm
<jcowan>
Although with Unicode we can use the combining macron to get much larger numbers.
<jcowan>
actually the combining overline
<fitzsim>
sounds like there's a need for a new library
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
<TMA>
alternatively it might just return (IIII) or (IV) ... with unicode CIIIIↃ or CIVↃ
OlCe has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
<jcowan>
True
<jcowan>
X̅X̅X̅I̅I̅DCCLXVII = 32767
<jcowan>
that turned "c" looks very wrong
hiroaki has joined #lisp
<jcowan>
CIↃ isn't that great either, because the C is in modern style and the Ↄ is in archaic style.
<ecraven>
hm.. maybe it's time to go and look for another font, patching bitmap terminus for everything isn't fun any longer, even if it is the best font I've found... are there outline fonts that are as crisp as proper bitmap fonts on normal dpi displays?
supercoven has joined #lisp
<TMA>
CIↃ is originally just greek phi Φ (D is just IↃ joined, similary L is half psi Ψ)
* Odin-
wrote a program that used symbols in futhark runes at some point.
<beach>
I like it!
supercoven has quit [Read error: Connection reset by peer]
gaze__ has quit [Ping timeout: 245 seconds]
gaze__ has joined #lisp
<TMA>
(the pattern is even more prevalent... V is half od X; all told, the roman numerals consist of letters IVXLΨDΦ or more commonly IVXLCDM)
<jcowan>
I think Greeks still use Greek numerals where we use Roman ones
<Nilby>
It's nice that (= (+ ೧೨೩೪ ५६७८) (+ 1234 ５６７８)) , but a little sad that (+ ⅠⅡⅢⅣ 5678) doesn't work.
<jcowan>
the alpha = 1, beta = 2 etc. etc.
<jcowan>
In general, Unicode distinguishes between digits and decimal digits, and place-value arithmetic only works on the decimal digits.
<jcowan>
Traditional Tamil numbers used the "3 100 4 10 5" pattern, but later a proper zero was added.
wsinatra_ has quit [Ping timeout: 246 seconds]
wsinatra has joined #lisp
<mfiano>
ecraven: You might like Iosevka (I switched to that from terminus a few years ago)
amb007 has quit [Read error: Connection reset by peer]
phantomics has quit [Quit: Ex-Chat]
amb007 has joined #lisp
Josh_2 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Nilby has quit [Ping timeout: 245 seconds]
OlCe has quit [Ping timeout: 246 seconds]
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
Aurora_v_kosmose has quit [Quit: brb]
Aurora_v_kosmose has joined #lisp
<matryoshka>
jcowan: lisp images are not just a dump of the environment table and the state of running processes to disk?
<matryoshka>
where/how did you find out about this? I've been trying to figure out the workings of lisp images for a while.
OlCe has joined #lisp
<beach>
matryoshka: I think jcowan is saying that by "Lisp image" it is often meant the live execution environment when the Common Lisp system is running.
<beach>
matryoshka: As opposed to the file on disk that, when loaded, creates that image.
<phoe>
then what do we call the "frozen" form of the image, created via things like save-lisp-and-die?
<phoe>
a core file?
<beach>
That would be SBCL specific.
phantomics has joined #lisp
<beach>
matryoshka: Though, if you have any questions about how a running Common Lisp system works, please do not hesitate to ask.
<phoe>
beach: yes, that's SBCL-specific; what's the general term?
<beach>
No idea. Sorry.
<Odin->
Is there a general term?
warweasle is now known as warweasle_workin
<MrtnDk[m]>
We can make one up, I guess?
<Bike>
a dumped image?
<beach>
"image template" maybe?
<phoe>
the docstring for uiop:dump-image says, "Dump an image of the current Lisp environment at pathname FILENAME, with various options."
<jcowan>
beach: Specifically, that's the meaning given in the CLHS glossary
<jcowan>
"dumped/saved/frozen image" would make sense to me
<beach>
jcowan: Aha, I hadn't realized that.
<fitzsim>
cl-launch uses the term "dumped image" and tries to support many Common Lisp implementations
<phoe>
CCL consists of a "heap image", a "lisp kernel", and an "interface database"
<beach>
phoe: Rainer is trumped by the glossary.
<Odin->
phoe: That definition is contradicted by a lot of usage.
<jcowan>
That is not, however, necessarily the correct definition in contexts other than the CLHS.
<jcowan>
"correct" in the sense of "most useful"
<beach>
Of course.
<phoe>
beach: Odin-: yes, I can see that
<_death>
a live image is called a video :)
<Odin->
I'm fairly sure I've seen references in modern documentation to "loading a system into the image" in the "an image is a live thing" sense.
<phoe>
so I'd say that around #lisp, an image, depending on context, can mean either the complete live state of a running Lisp system or its file-dumped form that can be restored back into a live Lisp system
<phoe>
because it seems to me that the term is used both ways
<phoe>
and whenever clarification is needed, "live image" and "dumped image" work well I guess
<jcowan>
When I loosely used the term "raise an exception" instead of "signal a condition" the other day, you (correctly but somewhat pedantically) corrected me. That got me to wondering: definitely "signal" is better than "raise" in the Lisp context, but I am not sure that the divergence between "condition (object)" and "exception (object)" carries any special meaning.
<Odin->
The thing is, the _obvious_ thing to do is to consider a file that can be loaded to (more or less) restore a given image to effectively _be_ that image...
<phoe>
jcowan: actually
<Odin->
jcowan: I think in that case the issue is that Common Lisp doesn't have anything it calls exceptions.
<beach>
jcowan: It didn't used to, but phoe introduced the difference.
<beach>
use to
<MrtnDk[m]>
_death: or a gif ...
<phoe>
conditions wind while exceptions unwind
<phoe>
that's the big difference
<beach>
phoe: But you made that up, right?
<phoe>
made what up
<beach>
phoe: The distinction you just mentioned.
<Odin->
beach: Sounds like an observation, more than anything.
<phoe>
no
<beach>
Oh?
<beach>
phoe: Where in the literature did you find those definitions?
<phoe>
signaling a CL condition winds the stack further, raising/throwing an exception usually unwinds the stack
<beach>
Says who if it isn't you?
<phoe>
at least the most popular exception systems work that way
<Odin->
I.e., systems based on exceptions do the unwinding, while CL ... yeah, exactly.
<jcowan>
Well, it winds the stack until and unless it decides to unwind it.
<phoe>
the former says CLHS, the latter says the way C++/Java/Python do exceptions
<Odin->
jcowan: True, but the fact that it doesn't immediately unwind it is the difference in question....
<jcowan>
I prefer to talk about termination vs. resumption semantics.
<phoe>
this difference in behavior is why I'm personally picky about "exceptions" in Lisp
zaquest has quit [Read error: Connection reset by peer]
<beach>
phoe: What if a new language uses "condition" for the unwinding type?
<beach>
phoe: Who would you complain to?
<phoe>
thank goodness we don't need to care about this at the moment
zaquest has joined #lisp
CrazyPython has joined #lisp
<beach>
phoe: My point is that you made up the difference and named it. I like it, but you did make it up. We do that all the time. Be proud of it.
<MrtnDk[m]>
😁👍
<phoe>
oh
<phoe>
okay
<Odin->
'made up' or 'noticed'.
<beach>
Odin-: Made it up, because there was no such semantics attached to the names before.
<MrtnDk[m]>
Cool. Well done phoe
<Odin->
beach: I get where you're coming from, but I also get why someone wouldn't think of it as having invented something.
<beach>
As Frank Zappa says: I for one care less for them.
<jcowan>
Scheme has exactly the the same resumption semantics as CL, but uses "exception handler" vs. "condition object".
<jcowan>
The beginning of science is the drawing of precise distinctions.
<jcowan>
(mathematics, too)
<beach>
Precisely my point. And naming those distinctions is important.
skapata has joined #lisp
mindCrime_ has joined #lisp
<Bike>
does scheme use continuations to resume? i mean, if there's an error, and the handler resumes to somewhere, does that unwind and rewind the stack in a way dynamic-wind deals with?
OlCe has joined #lisp
<_death>
phoe: do you know about Structured Exception Handling (SEH)?
<phoe>
_death: I do
<Bike>
whereas in lisp, resuming an exception is generally actually unwinding under the hood
amb007 has quit [Read error: Connection reset by peer]
ukari has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
<Bike>
not entirely under the hood, since you can observe unwinding with unwind-protect
<_death>
phoe: well, there some user code can run before the stack is unwound
<Bike>
"resuming an exception"... restarting i mean
<phoe>
yes, that's one thing - it's not standard C++ though, it's a Windows sort of extension
<_death>
phoe: right, it has nothing to do with C++
<jackdaniel>
I'm wounded in the stack
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rumbler31 has joined #lisp
gitgood has joined #lisp
<phoe>
wounding the stack sounds like a pretty tough condition
rumbler31 has quit [Ping timeout: 240 seconds]
<matryoshka>
beach: hmm. I see
<matryoshka>
So what exactly makes a live lisp system live?
<matryoshka>
Is it due to the nature of eval?
imuo has joined #lisp
<phoe>
what do you mean, "live"
<phoe>
you mean that it is in RAM and capable of executing stuff?
<matryoshka>
Being able to redefine functions while the lisp system is running, for example.
<phoe>
it's just design - in this case, late binding
<MrtnDk[m]>
matryoshka That and apply, I guess?
<phoe>
if you execute a function named FOO then you reach the actual code through the symbol FOO
<phoe>
so if you modify the place that the symbol FOO points you to, bam, you have just redefined that code for all pieces of code that reach that code through the symbol FOO
<phoe>
that's all
<matryoshka>
Yes, I figured it was like that.
<matryoshka>
Thank you.
<MrtnDk[m]>
phoe You can do that in see also though, right?
<phoe>
of course you can
<MrtnDk[m]>
s/see/C/
<MrtnDk[m]>
I don't remember how, but I think I did do it in the past.
<Odin->
Function pointers, one presumes.
<phoe>
get yourself an arra--- yes
<phoe>
make yourself a hash table from strings to structs, ensure that one of those struct fields is a function pointer, replace it via standard assignment of struct fields
<phoe>
congratulations, you have just implemented a very crude Lisp package!
<phoe>
as long as all callers go through this struct indirection, you can atomically replace function pointers for all of your system
<Shinmera>
why bother with structs? Just put a raw function poitner there
<_death>
syscalls and interrupt vector tables existed for many years ;)
<phoe>
if you only need functions then sure; I was thinking of structs that have things like variable/function/class bindings and such
<phoe>
but if we don't want fully featured symbols then just function pointers is enough
<Odin->
_death: I take it you don't work on microcontrollers, then?
<MrtnDk[m]>
phoe I wonder, if that is how, Emacs Lisp is implemented.
<phoe>
#emacs might be a good place to ask mayhaps
<phoe>
I never studied emacs internals too hard myself
<MrtnDk[m]>
Just thinking aloud.
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
<MrtnDk[m]>
I have been considering what it would take to implement a really basic Lisp-like thing in C.
<jackdaniel>
there is quite a few lisp-like languages (in C too)
<jackdaniel>
just type "lisp in c" in your favourite search engine
<jackdaniel>
you'll see lisp-in-c, lisp in less than 200 lines of c, learn c - build your own lisp yada yada ,)
<jackdaniel>
well, kyoto is not lisp-like thing in c, it is lisp
<aap>
it kinda is a toy lisp, but i also tried to implement most of the actual lisp 1.5
aartaka has quit [Ping timeout: 260 seconds]
<_death>
aap: hmm, it seems lisp 1.5 called it ERRORSET.. so Gabriel's paper has a typo ;)
cage_ has joined #lisp
<Odin->
MrtnDk[m]: Not much.
<Odin->
The more interesting question, in my view, is whether you can build a useful Lisp system on some of the more constrained systems that are in use nowadays.
wsinatra_ has joined #lisp
wsinatra has quit [Read error: Connection reset by peer]
<ecraven>
mfiano: just tried that with antialias=false, it's atrocious ;) like all non-bitmap fonts
<Odin->
What's the resolution?
skapata has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
curtosis has joined #lisp
rumbler31 has joined #lisp
skapata has joined #lisp
karlosz has quit [Quit: karlosz]
gitgood has quit [Remote host closed the connection]
skapata has quit [Ping timeout: 246 seconds]
mason has joined #lisp
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
dilated_dinosaur has quit [Ping timeout: 240 seconds]
dilated_dinosaur has joined #lisp
srandon111 has quit [Quit: leaving]
karlosz has joined #lisp
VincentVega has joined #lisp
yitzi has joined #lisp
<White_Flame>
Odin-: useful lisp system, or useful common lisp system?
<White_Flame>
when RAM is measured in KB, the footprint of just the CL symbols can be challenging
<Odin->
Lisp. CL is too big.
gitgood has joined #lisp
<Odin->
Heck, ISLISP is probably too big.
* Odin-
has been messing around with uLisp, which is on the periphery of 'useful'.
<jcowan>
Odin-: you might want to take that question to ##lisp
<White_Flame>
of course there's picolisp as well
<jcowan>
And tinyscheme
OlCe has quit [Ping timeout: 268 seconds]
<_death>
Odin-: I played with ulisp a month ago or so (on an m5stickc), but indeed it's a bit limited (no compilation/macros).. I think something like a vm running clisp's bytecode or a subset of it could be nice
Inline has joined #lisp
yitzi_ has joined #lisp
yitzi_ has quit [Client Quit]
yitzi has quit [Ping timeout: 240 seconds]
jackdanie1 has joined #lisp
jonatack has quit [Ping timeout: 268 seconds]
jackdaniel has quit [Quit: ()]
jonatack has joined #lisp
jackdanie1 is now known as jackdaniel
rumbler31 has quit [Remote host closed the connection]
wsinatra_ has quit [Read error: Connection reset by peer]
wsinatra has joined #lisp
sxmx has quit [Quit: WeeChat 3.1]
warweasle_workin is now known as warweasle
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
rogersm has quit [Quit: Leaving...]
karlosz has quit [Quit: karlosz]
skapata has joined #lisp
cage_ has quit [Quit: Leaving]
flazh has quit [Ping timeout: 240 seconds]
flazh has joined #lisp
andrew2 has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cosimone has joined #lisp
wsinatra has quit [Ping timeout: 246 seconds]
andrew2 has quit [Quit: Connection closed]
anticrisis has joined #lisp
Faed is now known as Fade
dilated_dinosaur has quit [Ping timeout: 260 seconds]
dilated_dinosaur has joined #lisp
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
<MrtnDk[m]>
uLisp or μLisp?
jonatack has quit [Quit: jonatack]
warweasle has quit [Quit: later. Going home.]
lotuseater has joined #lisp
karlosz has joined #lisp
<moon-child>
Odin-: I'm a fan of s7 scheme
<moon-child>
Odin-: there's also sectorforth, for the truly constrained systems
mindCrime_ has quit [Ping timeout: 240 seconds]
<Odin->
MrtnDk[m]: See http://www.ulisp.com - but as noted, this is getting off topic.
<MrtnDk[m]>
Odin- can you invite me to ##lisp ?
<Odin->
moon-child: Well, of course, that's something Forth excels at...
<Odin->
It requires invitation?
<MrtnDk[m]>
wait, it might not be bridged
GFP2242 has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
flazh has quit [Quit: flazh]
narimiran has quit [Ping timeout: 240 seconds]
flazh has joined #lisp
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
galex-713 has joined #lisp
GFP2242 has quit [Quit: This computer has gone to sleep]
Spawns_Carpeting has joined #lisp
<phoe>
it does not require an invitation
<phoe>
just /join ##lisp works for me
klltkr has joined #lisp
kenran has joined #lisp
tomaw has quit [Read error: Connection reset by peer]
yonkunas has quit [Quit: Connection closed for inactivity]
tomaw has joined #lisp
Inline has quit [Quit: Leaving]
mindCrime_ has joined #lisp
<MrtnDk[m]>
phoe: I'm on Matrix. I'm not sure how to join an IRC room, even if it is bridged and has no invitation requirement.
<fiddlerwoaroof>
MrtnDk[m]: I think there's just a naming convention
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
cchristiansen has joined #lisp
nullman has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has joined #lisp
nullman has joined #lisp
tiwEllien has quit [Ping timeout: 246 seconds]
curtosis is now known as curtosis[away]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
Lord_of_Life has quit [Ping timeout: 246 seconds]
shka_ has quit [Ping timeout: 260 seconds]
sxmx has joined #lisp
<MrtnDk[m]>
#freenode_#common-lisp.net I'm guessing, if it be bridged.
<MrtnDk[m]>
* On the matrix it might be room #freenode_#common-lisp.net I'm guessing, if it be bridged.
lottaquestions has quit [Quit: Konversation terminated!]
lottaquestions has joined #lisp
<mason>
MrtnDk[m]: Ah, I don't use Matrix. I was able to find it more simply.
<etimmons>
Mrtn Dk: yes (coming from a fellow Matrix user on that channel). Also, my understanding is that all of Freenode is "bridged"
surabax_ has quit [Quit: Leaving]
pve has quit [Quit: leaving]
cosimone has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 252 seconds]
nij has joined #lisp
<nij>
Hello! I recently started writing a personal project using emacs-lisp. It crashed me on performence so I wonder if I should switch back to common lisp.
<nij>
For now, my database is just a folder with ~7500 files. Each file contains one lisp list.
<nij>
I have never dealt with a database before, so I must be doing something wrong. But in any case, the performence is very bad. It is not clear in my head when I should read/write from/to the database, or when I should just use the variable to hold things.
<nij>
I wonder if switching back to common-lisp would solve this problem. I've heard of the power of CLOS, but have never experienced it in depth. That's my situation. So.. any advice would be appreciated.
<nij>
Thanks!
indathrone has quit [Quit: Leaving]
<phoe>
nij: how big is your database in total, in kilobytes/megabytes?
<nij>
~2MB
<nij>
I expect it to grow 1.5M/year.
<phoe>
no need to stretch it across so many files
<phoe>
it's relatively tiny and you could even hold everything in memory
<nij>
But I need it to stay after the program is halted.
<phoe>
no no; keep the data in memory for access, but also write a backup copy of it to disk
* Odin-
pokes at SQLite.
<phoe>
also, yes, sqlite - unless you'd like to try a pure-CL solution of sorts, or try to reinvent the wheel for some personal learning
<nij>
i guess it's time for me to seriously learn to use db..
<phoe>
mito is actually more than just a DB or DB interface
<phoe>
it is an ORM software which is something even more different
<nij>
it's clos+db, right?
<phoe>
do you know what is a relational database, and how its data differs from object-oriented data?
<phoe>
if not, you should - and then you'll know that ORM is a toolkit that attempts to bridge that difference
<nij>
relational dbs are based on spreadsheets, and oo data are lots of classes,instances, and slots?
<moon-child>
'relational dbs are based on spreadsheets' wat
<moon-child>
data representation is slightly similar, and problem domain has some overlap, but the two have wildly different roles
<nij>
moon-child: i dunno what im talking about. this's just my impression.
<moon-child>
spreadsheet is end-user data flow & analysis. Relational db is relational algebra (=academia goodness) + long-term data storage & representation
<nij>
@@ i dunno what that means
<nij>
and when i read wikipedia, idk either..
VincentVega has quit [Quit: Connection closed]
<moon-child>
dunno what what means?
random-nick has quit [Ping timeout: 246 seconds]
OlCe has joined #lisp
casual_friday has quit [Remote host closed the connection]
Helmholtz has joined #lisp
casual_friday has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
<White_Flame>
nij: for something that's going to stay under 10MB for years from now, a simple persistence to log file and keeping all of it in RAM would be fine :-P
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
varjag has quit [Ping timeout: 252 seconds]
anticrisis has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
<markasoftware>
the simplest thing to do is just maintain it all in memory under a single top level variable, then use cl-marshal or similar to serialize it to a single file on disk periodically
<markasoftware>
as long as the D of ACID isn't super important to you
<Xach>
writing a log can be helpful for the durability.
ukari has joined #lisp
igemnace has joined #lisp
mindCrime_ has joined #lisp
karlosz has joined #lisp
gaqwas has quit [Ping timeout: 240 seconds]
<jcowan>
The main advantage of SQLite in this context is that it works very hard to either persist your data or fail.
<jcowan>
If you have an easy sqlite setup, then "INSERT INTO log VALUES (?)" with ? bound to the line to be logged is just about as easy as writing to a file.
OlCe has quit [Ping timeout: 246 seconds]
akoana has joined #lisp
long4mud has joined #lisp
<Xach>
yes, it would be much safer and more reliable. but if you go the diy route, a log is an easy step beyond stashing all the data from memory periodically.
aeth_ has joined #lisp
<Xach>
and by log, i don't mean syslog things, i mean writing out data records, as in "write-ahead logs" or "commit logs"
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
rumbler31 has joined #lisp
<nij>
White_Flame: that's a nice rule of thumb! thanks :)