zooey has quit [Remote host closed the connection]
zooey has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
ealfonso has quit [Ping timeout: 260 seconds]
ealfonso has joined #lisp
zaquest has quit [Quit: Leaving]
iissaacc has joined #lisp
borei has joined #lisp
Kaisyu7 has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 265 seconds]
__jrjsmrtn__ has joined #lisp
karlosz has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
zaquest has joined #lisp
ealfonso has quit [Ping timeout: 260 seconds]
Bourne has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
Jeanne-Kamikaze has joined #lisp
ex_nihilo has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
AeroNotix has quit [Quit: WeeChat 2.9]
cosimone has quit [Quit: Quit.]
sjl has quit [Quit: WeeChat 2.2-dev]
karlosz has quit [Quit: karlosz]
marusich has quit [Ping timeout: 260 seconds]
patlv has joined #lisp
notzmv` has joined #lisp
dominic34 has joined #lisp
dominic34 has quit [Excess Flood]
notzmv has quit [Disconnected by services]
dominic34 has joined #lisp
notzmv` has quit [Changing host]
notzmv` has joined #lisp
notzmv` is now known as notzmv
akoana has quit [Quit: leaving]
jesse1010 has quit [Ping timeout: 256 seconds]
notzmv` has joined #lisp
notzmv` has joined #lisp
notzmv` has quit [Changing host]
notzmv has quit [Disconnected by services]
ebzzry has joined #lisp
notzmv` is now known as notzmv
dominic34 has quit [Ping timeout: 272 seconds]
ebzzry has quit [Remote host closed the connection]
sjl has joined #lisp
Stanley00 has joined #lisp
Volt_ has quit [Quit: ]
<beach>
Good morning everyone!
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
notzmv` has joined #lisp
toorevitimirp has joined #lisp
notzmv has quit [Ping timeout: 240 seconds]
notzmv` has quit [Changing host]
notzmv` has joined #lisp
notzmv` is now known as notzmv
<borei>
hi beach, was watching the video, you shared link on Friday, - pretty good one. Dosn't agree how was overall computing power was estimated, but in general - yeah, there is no fundamental changes in last almost 70 years
space_otter has quit [Remote host closed the connection]
<beach>
borei: Oh, the one by "Uncle Bob"?
<borei>
yep
<beach>
Great. Again, I think that since he is an important figure, this video may have some impact.
<borei>
im not professional programmer, and always missing some fundamental things, and videos like that one are filling such gaps in my knowledge
<borei>
i shared it with mu colleagues at work - hmm, they either didn't watch it or didn't get ideas.
<beach>
I see. Well, I am not a "mainstream" programmer, so I am missing lots of fads like micro services, Java IDEs, Scrum, TDD, etc. And his other videos fill me in in a similar way.
<borei>
that is frustrating
<beach>
Sure.
hendursaga has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
<beach>
He has a long lecture series entitled "Clean Code" that I watched for that reason.
hendursaga has joined #lisp
<borei>
that would be cool to watch - just need to deal with my custom logger, which is already becoming pretty dirty :-)
<beach>
Heh, sure. I watch those videos while doing my daily physical exercise, so it doesn't take any additional time for me.
mindCrime_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
iissaacc has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 244 seconds]
orivej has quit [Ping timeout: 258 seconds]
yokoyamachan has joined #lisp
dale has quit [Remote host closed the connection]
dale has joined #lisp
dale has quit [Remote host closed the connection]
dale has joined #lisp
narimiran has joined #lisp
<HiRE_>
borei: I will tell you that if it wasn't for being in school all of my interest in actual computer science would've atrophied by now
<HiRE_>
combine that with drinking an entire vat of lisp koolaid industry fads have left me very jaded.
<beach>
I guess the lack of commas, makes the last sentence ambiguous.
<beach>
I mean what are "lisp koolaid industry fads"?
epony has quit [Ping timeout: 258 seconds]
<beach>
And what does it mean to be in "school all of my interest"?
<borei>
i was trying to get an idea, but for person with not native english language - it's a bit tough sentence :-)
<beach>
It's a simple thing of missing commas, I think.
<HiRE_>
yes
<HiRE_>
I drank a bowl of lisp koolaid
<aeth>
My guess is "I will tell you that โ if it wasn't for being in school โ all of my interest in 'actual computer science' would've atrophied by now"
<HiRE_>
now I am jaded
<aeth>
"combine that with drinking an entire vat of lisp koolaid, industry fads have left me very jaded."
<beach>
Yeah, sounds right.
<aeth>
of course, the fun thing about missing punctuation is that you can insert it as you wish
<HiRE_>
I just wanted to teach everyone about parse trees
<borei>
question about garbage collector. for example i have object which is holding open file stream, object is getting collected by garbage collector for what-ever reason, how can i make sure that object releases file stream properly.
<beach>
HiRE_: When a reader sees "school all of my", something like "early life".
<beach>
is expected.
<HiRE_>
I've been speaking english for 30 years and I will never understand it
<beach>
borei: In a lot of garbage collection technique, you can't.
<borei>
basically i need to close file (in my case), then object can be destroyed
<beach>
borei: The term is "finalization" and it's a controversial subject.
<HiRE_>
finalization in java isnt even guaranteed
<HiRE_>
its more like a suggestion
<borei>
beach: does it mean that i have leaking program ?
<beach>
borei: Probably. That's why we have constructs such as WITH-OPEN-FILE.
<HiRE_>
incredible that it took python so long to copy WITH-OPEN-FILE
ebzzry has joined #lisp
<HiRE_>
huh...whats interesting though is that the GC would collect the object even though its holding a reference to another object.
<beach>
HiRE_: What? An object is "collected" if it is not referred to. What it refers to is of no importance.
<aeth>
And this is why finalizers are controversial. You don't really know if some resource you want freed is still being referred to somewhere.
<borei>
hmm, seems like in my case i need to call "destructor" explicitly before program termination.
ebzzry has quit [Remote host closed the connection]
<beach>
borei: Like I said, many GC techniques don't even touch garbage objects, so you can't call anything on them.
<aeth>
borei: That's generally done with UNWIND-PROTECT, generated via the WITH-FOO-BAR macro pattern.
<beach>
HiRE_: What "reference counting" are you referring to?
ebzzry has joined #lisp
<no-defun-allowed>
I think the Python documentation says you can't rely on finalizers to close files, which is quite ironic, given that refcount weenies like to say you can use refcounting to manage other resources.
<beach>
HiRE_: No serious language implementation uses reference counting. It is flawed, and at least an order of magnitude slower than tracing garbage collection.
<aeth>
heh
<no-defun-allowed>
"Notably, both Java and Python do not guarantee that finalizers will ever be called, and thus they cannot be relied on for cleanup."
<aeth>
beach: Unfortunately, it's in style again. Maybe they found an efficient approach, or maybe they just forgot.
<beach>
aeth: In what serous language implementation is it used?
<no-defun-allowed>
From memory, CPython uses reference counting and a generational non-moving collector to break cycles, so you get the worst of both worlds (refcounting performance, or lack thereof, and "random" stop-the-world pauses).
<aeth>
Although, to be fair, a lot of those languages don't emphasize being fast.
<no-defun-allowed>
Also from memory, C++, Swift and Objective-C, Rust, and Vala.
<no-defun-allowed>
aeth: I think the first four of my subset do.
<beach>
aeth: Those are not "serious" as far as I can tell. Pretty much by definition.
<beach>
aeth: Let me say this again; It is impossible to write a C++ program that is both modular and fast, and the reason is lack of automatic memory management. Adding reference counters makes the code at least an order of magnitude slower than the equivalent code in a serious language, and it still has memory leaks. I don't consider that "serious". It's a joke.
<beach>
But since C++ programmers are convinced that the generation of fast code by the compiler is all that counts, they do not see the problem, since they are not comparing the code to the equivalent in a serious language.
<no-defun-allowed>
C++ is a joke taken way too far, Swift and O-C are the only jokes you get on iOS from memory, we won't talk about the fourth one, and one Linux distribution used Vala to rewrite everything because the applications otherwise would look too different.
<contrapunctus>
beach: there's a little No True Scottsman here :) (arising from "serious", which is ill-defined) "no serious language uses X" "language L uses X" "language L is not a serious language" (NB I haven't really programmed in any non-Lisp and don't really like anything else, so I'm not at all defending anything here)
<beach>
Sure, on #lisp everything has to be debated to death.
toorevitimirp has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
And for the first four of the subset I gave, their absurd idea of "real-time" which somehow allows the strange performance of malloc-ing but not garbage collecting trumps all, despite that no one I've seen that made the point has had to write a real-time system.
toorevitimirp has joined #lisp
<contrapunctus>
There's a "scriba" on https://www.quicklisp.org/beta/releases.html but `(ql:quickload :scriba)` says "System "scriba" not found" ๐ค Here's what I've tried - `(ql:where-is-system :scriba) ;; => NIL`, `(ql:system-apropos "scriba") ; No value`, `(ql:update-dist "quicklisp") ;; => You already have the latest version of "quicklisp": 2020-07-15. ;; => NIL`
<no-defun-allowed>
One "realistic" example of a real-time system is a printer which can't pause while it's printing, because it has to control the inkjets/laser/etc. Knowing printer software, a printer wouldn't be doing very much consing while setting hardware registers according to the pixels in the page image it rendered out.
<no-defun-allowed>
contrapunctus: Interesting. (ql:system-apropos "scriba") provides system descriptions that look like those on the releases page.
<no-defun-allowed>
...here.
<aeth>
no-defun-allowed: I'm not sure there are any RTGCs outside of the JVM, and then you have to use the JVM.
<aeth>
at that point, C++ starts looking like an option...
<no-defun-allowed>
aeth: selwyn told me that the Memory Pool System has a realtime mode, but it's proprietary. That one Lisp space project used LispWorks with a realtime collector.
<contrapunctus>
no-defun-allowed: what can I do to fix this? ๐
<no-defun-allowed>
contrapunctus: I'm not sure, sorry.
<contrapunctus>
Welp ๐ถ
Fare has quit [Quit: Leaving]
space_otter has joined #lisp
<no-defun-allowed>
aeth: Also, I wrote an incremental collector. It's probably not very good, but that is a "RT"GC outside of the JVM.
<beach>
OK, so let's analyze the situation: What could possibly be the reason for a designer of a language to use manual memory management? And what could possibly be the reason for using reference counters instead of a tracing garbage collector in a system with automatic memory management? And then let's see of any of those arguments qualify as "serious".
Lord_of_Life_ has joined #lisp
<beach>
Manual memory management is slower than automatic memory management, so that can't be a reason.
Lord_of_Life has quit [Ping timeout: 260 seconds]
<beach>
Manual memory management makes modularity impossible so that can't be a reason.
<no-defun-allowed>
I've read up on C++ and Rust for writing a book (half of which is arguing why one should use dynamic systems); and refcounting is what you do there when the lifetime of an object isn't immediately obvious.
Lord_of_Life_ is now known as Lord_of_Life
<beach>
Plus manual memory management is not "real time" if you `delete' a big data structure.
<beach>
Reference counting is at least an order of magnitude slower than tracing, so that can't be a reason.
<beach>
Reference counting is flawed in that it can't handle cycles, so that can't be a reason.
<no-defun-allowed>
C++ does whatever, but Rust uses something like linear typing most of the time.
<beach>
Reference counting is not real time if it calls `delete' on a big data structure, so that can't be the reason.
<no-defun-allowed>
Oh, actually the reason for Rust is gloriously awful; it was supposed to use a tracing garbage collector optionally, but the LLVM support for garbage collection wasn't up to scratch at the time.
<aeth>
no-defun-allowed: RTGC = niche and potentially used by HFT, so, yeah, not surprising that it's often proprietary. There's always trade-offs, though, and the gold standard for this sort of thing isn't merely real-time, though.
<contrapunctus>
beach: I see...thank you for explaining it in detail.
<beach>
I saw a presentation by a member of the Rust committee or whatever decides on the language, and he was under the false impression that tracing garbage collection is slower than manual memory management, so the entire reason for the existence of the language is based on incorrect assumptions.
<contrapunctus>
I removed ~/quicklisp/ and installed it again, and we're back in business. ๐
<no-defun-allowed>
That may still be the case; I recall drmeister was still not happy with the precise GC interface for LLVM, so Clasp uses the Boehm conservative collector, and will probably migrate to a (semi-)conservative collector like the Memory Pool System.
<beach>
And it is possible that only Java has a commercial real-time garbage collector, but real-time garbage collectors exist, so there is no reason to design a language or an implementation of a language as if they don't exist.
<no-defun-allowed>
contrapunctus: Great to hear, though I'd hope it was fixable somehow without resetting Quicklisp.
<beach>
If anyone can think of any remaining instances of "serious", I am all ears.
<beach>
"I don't now how GC works, so I'm designing this language without it" doesn't count.
<beach>
"My friend told me that GC is slow" doesn't count either.
<no-defun-allowed>
As well as the weird definition of "real-time", there's also the hope that their code will run on microcontrollers if they eschew a runtime and GC. Yet I also haven't seen anything that would run on a microcontroller.
<aeth>
beach: Yes, but now you've turned a programming language design project into a garbage collector implementation project.
<no-defun-allowed>
aeth: Actually, ECL uses the Boehm garbage collector, and it can be configured to run incrementally.
<aeth>
no-defun-allowed: You can use *a* GC as a library, but you cannot use *the* GC that answers these objections as a library, since it's hard and cutting edge.
ebzzry_ has joined #lisp
<aeth>
no-defun-allowed: but, yes, there's also the hope that one's language can compete with C and C++ if it doesn't have a GC, since the only people still using C and C++ are people who hate GC, and there's less competition there
<beach>
aeth: So "I would rather design a language that is way worse than existing ones in terms of performance, modularity, and correctness, than to learn how to implement a garbage collector" is "serious"?
<aeth>
beach: In the worse is better sense... Other languages started around the same time and doing things the correct way are probably still implementing their GC.
ebzzry has quit [Ping timeout: 240 seconds]
froggey has quit [Ping timeout: 260 seconds]
anewuser has joined #lisp
froggey has joined #lisp
Patzy_ has quit [Quit: WeeChat 2.9]
<no-defun-allowed>
I would say that a linear typing compiler goes "the other way" on correctness, and marks safe programs as unsafe; but for modularity, well, you have to_foo and as_foo which explicate memory management (to destroying the original object, as not destroying it).
gravicappa has joined #lisp
Blukunfando has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
And I am reminded of a blog post that resurfaced in #lispcafe: <https://abramov.io/rust-dropping-things-in-another-thread> -- though it lies in the sense that the thread told to deallocate the object is still burning CPU time.
<no-defun-allowed>
beach: Though I think #lisp might be the wrong place to ask; where continuing that line of thought would go is off-topic, and if one is in #lisp, they probably use Common Lisp, and have accepted a GC to some extent.
<beach>
Maybe so.
<beach>
I seriously recommend the video by "Uncle Bob" that I posted a link to the other day, and that borei apparently watched.
<aeth>
no-defun-allowed: unless someone has designed a non-GCed subset of Common Lisp
<aeth>
Amusingly, you could probably do it so the runtime is non-GCed, but the macro system uses the full language.
<no-defun-allowed>
Well, selwyn has expressed that they would prefer a lower latency collector for virtual reality experiments, and I'm honestly a bit annoyed with pause times with large heaps, but for the most part what free Lisp implementations have is good enough.
<beach>
That would be very different from a subset of Common Lisp, or it would just have fixnum arithmetic.
<aeth>
or floating point
<beach>
Right.
<no-defun-allowed>
Yeah, how much would you have to take away from Common Lisp to do that? You are always one EVAL or COMPILE away from trashing static analysis, and inter-function call stuff would also be trashed with (SETF FDEFINITION).
<aeth>
you could probably express quite a bit
<beach>
no-defun-allowed: I understand that most cores on a typical desktop usually do nothing. There are published GC algorithms that could use different threads for concurrent and real-time GC.
<beach>
Ignorant hackers who design and implement their own languages of course would not bother reading up on thoes.
<beach>
those.
<aeth>
no-defun-allowed: for one thing, if floats work, pretty much any numerical algorithm would be expressable as long as it's on fixed-sized arrays.
toorevitimirp has quit [Quit: Konversation terminated!]
<no-defun-allowed>
beach: Quite possibly, but I would not want to use the "optimisation" presented on a server, or a program that is usually busy doing things. And in the case of a command line program (the subject of an article), you could just exit early and let the OS drop the memory (which is basically free), or you wait for that thread to finish cleaning up (which is one thread creation slower than before).
abhixec has quit [Ping timeout: 272 seconds]
toorevitimirp has joined #lisp
enzuru has quit [Quit: Lost terminal]
<aeth>
no-defun-allowed: and I believe the idea of such a subset would be to, essentially, error on things like EVAL or COMPILE or anything else that could break the subset.
<aeth>
(by simply not including them in the subset)
<beach>
Using more threads is not necessarily a way of making if faster, but a way of avoiding pauses.
<no-defun-allowed>
Ah, okay.
Jeanne-Kamikaze has quit [Quit: Leaving]
<aeth>
beach: right... mainstream desktop processors these days are 6-16 cores, with high-end/workstation CPUs going up to 64 cores (128 threads)
<beach>
aeth: Even with integer arithmetic, it would not be a subset.
<beach>
aeth: You would have to change the semantics too.
<beach>
So, then calling it a "subset of Common Lisp" would be a stretch.
<aeth>
beach: It could error on bignum, but optimize (like SBCL already does) various ways to keep it fixnum, like MOD
<beach>
But that is not what the standard says, so you would change the semantics.
<no-defun-allowed>
(I do have a tale about them "not bothering to read up", but I don't like my reaction in hindsight, and that's also off-topic.)
<beach>
Tell it in #sicl some time.
<no-defun-allowed>
Alright, your generic dispatch scheme comes up, so it wouldn't be off-topic there actually.
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
Gerula has quit [Ping timeout: 260 seconds]
Blukunfando has joined #lisp
anewuser has quit [Quit: Leaving]
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
johnjay has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
yokoyamachan has joined #lisp
toorevitimirp has joined #lisp
pi123 has joined #lisp
contrapunctus has joined #lisp
Cymew has joined #lisp
ibinderwolf has joined #lisp
borei has quit [Ping timeout: 260 seconds]
aartaka has joined #lisp
<ex_nihilo>
\part
ex_nihilo has left #lisp ["Leaving"]
Inline has joined #lisp
schweers has joined #lisp
patlv has joined #lisp
marusich has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
marusich has quit [Ping timeout: 260 seconds]
toorevitimirp has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 272 seconds]
Patzy has joined #lisp
liberliver has joined #lisp
aartaka has joined #lisp
ayuce has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
gaqwas has quit [Remote host closed the connection]
aartaka_d has quit [Ping timeout: 264 seconds]
mathrick has quit [Ping timeout: 272 seconds]
patlv has quit [Ping timeout: 260 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
pve has joined #lisp
ljavorsk has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
galex-713 has joined #lisp
edgar-rft has quit [Quit: Leaving]
jprajzne has joined #lisp
rogersm has joined #lisp
gaqwas has quit [Remote host closed the connection]
<contrapunctus>
A real time GC might be important for me, because I'm thinking of writing a DAW, sequencer, and video editor in Lisp.
Gerula has joined #lisp
<moon-child>
contrapunctus: possibly try abcl, and one of the low-latency java gcs? Abcl is not super fast, but should satisfy your latency reqs
<aeth>
contrapunctus: I'm guessing you're talking about audio?
<aeth>
contrapunctus: in that case, ouch... sounds like it would be tough
<no-defun-allowed>
If you don't cons, the GC won't run.
hendursa1 has joined #lisp
<beach>
I designed the nursery collector of SICL to be good enough for audio. It hasn't been tested in real life of course.
<no-defun-allowed>
Pre-allocating temporary buffers should be doable with audio at the least.
<contrapunctus>
aeth: yeah. But I guess I'll be using C wrappers for the audio/video, so maybe it won't be a problem... ๐ค
<beach>
Oh dear.
<contrapunctus>
beach: ? ._.
hendursaga has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
(With a complicated networking system, you do cons here and there, and it's a bit harder. But after being pressured to do so by the SICL bootstrapping instructions two years ago, I've run SBCL with very large heaps, which I think lengthens pause times.)
davepdotorg has joined #lisp
<no-defun-allowed>
(But now, would I rather decrease the heap size by default to do latency tests every so often, and have problems when I want to use more objects, or keep the heap size large and remember to shrink it when testing?)
<beach>
contrapunctus: I have explained my position a gazillion times, but in summary, when people use C code to solve their immediate problems, they collectively spend a lot of time debugging and asking questions here, and it does not benefit Common Lisp at all.
<beach>
If each person instead created a library or an application is pure Common Lisp, then the situation would be the opposite, namely that everyone would benefit in the end.
shangul has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
ebzzry_ has quit [Quit: WeeChat 2.8]
ebzzry has joined #lisp
scymtym has quit [Remote host closed the connection]
<beach>
s/is pure/in pure/
<ebzzry>
Good day, everyone!
<beach>
Hello ebzzry.
<contrapunctus>
beach: hm...I'm iffy about using C libraries, too, because most of the programs I've used are written in C/C++ and are also super crashy...which causes me no end of frustration as a user.
<no-defun-allowed>
Hello ebzzry.
jw4 has joined #lisp
<ebzzry>
Howโs lisping?
<beach>
ebzzry: Quite good. I am looking forward to scymtym's presentation of Eclector, hopefully for the next online Lisp meeting.
<beach>
ebzzry: And the work of jackdaniel on Clostrum (implementation-independent library for improved first-class global environments) is shaping up enough that I can use it in SICL bootstrapping.
<no-defun-allowed>
Pretty good, though I'm taking a break to write a book and explore the design space. Also definitely looking forward to the Eclector presentation, because the small demos scymtym made are very impressive.
<aeth>
contrapunctus: If only there was a reliable, safe language that people could rewrite their C/C++ applications in.
<contrapunctus>
aeth: ๐
frgo has quit [Ping timeout: 256 seconds]
Gerula has quit [Ping timeout: 265 seconds]
<contrapunctus>
Well, implementing audio/video isn't my idea of fun, but if it helps Lisp/make better programs, sure...I might try.
<ebzzry>
Thatโs good to know!
<ebzzry>
May I ask, among the open-source implementations, which has the best story with standalone executables with multithreading?
<ebzzry>
On Windows 10, I forgot to mention.
<aeth>
Depends on which architecture you're talking about. Iirc, SBCL doesn't have multithreading on ARM? Or something like that.
<no-defun-allowed>
Clozure by a hairs' width, because it'll run multithreaded on 32-bit ARM before crashing cause of a GC bug, unlike SBCL which won't run at all threaded. If that doesn't matter, either of those is fine.
<aeth>
I'd probably use SBCL for standalone executables.
<ebzzry>
I forgot to mention, my bad, that itโs constrained for CL on Windows.
<no-defun-allowed>
That should still hold on Windows; I think SBCL used to warn you threads weren't stable on Windows, but I never had problems with it.
<ebzzry>
no-defun-allowed: The app works well on mac and linux, but not on SBCL/Windows.
<no-defun-allowed>
Weird then.
hendursa1 has quit [Ping timeout: 240 seconds]
<ebzzry>
no-defun-allowed:indeed.
orivej has joined #lisp
<no-defun-allowed>
I think about two years ago I technically "deployed" a program to SBCL/Windows and had some people run it; what goes wrong?
hendursa1 has joined #lisp
<ebzzry>
no-defun-allowed: hunchentoot enncounters an error, wherein, the other additional thread is not working properly, or it can't control.
<no-defun-allowed>
Even more weird, because I used Hunchentoot then.
<ebzzry>
no-defun-allowed: i'll open the code sometime this week, then i'll show the relevant parts
<no-defun-allowed>
Yeah, that would be useful in figuring out what's going wrong.
Gerula has joined #lisp
ted_wroclaw has joined #lisp
scymtym has joined #lisp
iamFIREcracker has quit [Read error: Connection reset by peer]
frgo has joined #lisp
iamFIREcracker has joined #lisp
camlriot42 has left #lisp ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
aartaka has quit [Ping timeout: 240 seconds]
<shangul>
How can I access stuff from a C++ shared library from Common Lisp? It seems that CFFI is just for C and does not support classes
<White_Flame>
clasp
<no-defun-allowed>
"Yes, you have the rest of CL for classes..." I read about a prototype for a C++ wrapper making thing recently.
<shangul>
White_Flame, But that's an implementation. Am I going to force people to use Clasp to use my C++ library?
<schweers>
shangul: depends. Can you create a wrapper library in C?
<White_Flame>
well, the function call ABI and how it interacts with the machine language is something that's very implementation-specific. I don't really see how you could build up C++ support in a portable CL way currently
<White_Flame>
without going full turing tarpit
<shangul>
schweers, Users of my c++ library need to create a subclass of a parent class and override methods.
<shangul>
schweers, So I guess no
<beach>
contrapunctus: See what I mean?
<schweers>
Oh, I see.
<shangul>
White_Flame, Thank you I will see what I can do
<schweers>
beach: On a related note: do you believe that there are ever performance reasons which justify using C instead of a free Common Lisp implementation like SBCL?
<shangul>
no-defun-allowed, Thanks for your reply
<beach>
schweers: Not for what I call "application programming". For "system programming" there might be some reasons. By "system programming" I mean code that needs access to low-level memory and such, so essentially using C in a way that is not defined by the C standard.
<schweers>
Well yes, I was talking about Application Programming. Would you consider using foreign memory via CFFI as part of Common Lisp with regards to your answer?
<beach>
schweers: I can also imagine using C for a small specific module in an application that is overall written in Common Lisp, perhaps is the Common Lisp implementation is unable to optimize some specific aspect.
<beach>
schweers: I think my second answer covers that situation, no?
<schweers>
Well, I wasnโt talking about writing the whole application in C
<no-defun-allowed>
shangul: Would it be possible to write the library in Common Lisp?
<contrapunctus>
beach: ๐
<no-defun-allowed>
If you would subclass from CL, it's not that much of a stretch.
<beach>
schweers: It is my experience that people turn to C and CFFI for performance reasons when they feel they need to do some low-level stuff to improve performance. But the same people then typically blow it completely when it comes to data structures and algorithms in the rest of the code, which would benefit overall performance a lot more if done better.
<schweers>
heh, I see what you mean
<shangul>
no-defun-allowed, yeah after one year or two XD
<schweers>
I once used CFFI and mmap to produce a binary file. In restrospect Iโm not sure that was such a great idea.
<no-defun-allowed>
shangul: I'm sorry to hear that.
<no-defun-allowed>
Yeah, :element-type '(unsigned-byte 8) would have worked. (But I do mmap files in my grep clone to read them, so...)
<schweers>
shangul: create a single subclass which has explicit function pointers. Create C wrappers to change these function pointers at runtime, use CFFI. Ugly, but might work. I guess youโll have to judge whether itโs better to do this or rewrite in Lisp.
<shangul>
no-defun-allowed, I didn't write the C++ library myself. I just used codes of the project which was written in C++ and created a wrapper class.
<shangul>
schweers, or use Clasp?
<schweers>
Or that. Iโve never used clasp, so I canโt comment on it.
<shangul>
Rewrite in Lisp is completely a bad idea so I should judge between Clasp and what you said
jesse1010 has joined #lisp
treflip has joined #lisp
frgo has quit [Ping timeout: 264 seconds]
<shangul>
Anyone has a compiled version of clasp for Linux x86_64?
<shangul>
oh wrong channel
mathrick has joined #lisp
yitzi has quit [Quit: yitzi]
space_otter has quit [Remote host closed the connection]
yitzi has joined #lisp
cosimone has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
<bhartrihari>
beach: Perhaps we could use a list of foreign libraries that people need help reimplementing; in case any lispers want to help. Like the projects suggestion list on cliki. That could lift off the burden from one dev (team) alone. The community could help when the projects are burdensome for individuals. Perhaps it's the one sided burden of your suggestion that people react negatively to (unless they are
<bhartrihari>
really passionate about purity in Lisp).
<beach>
That's a big one that would be very useful for McCLIM, and Mezzano.
<scymtym>
beach: harfbuzz?
<beach>
A Common Lisp replacement for it, yes.
<beach>
Thanks for reminding me of the name.
<beach>
Time for a lunch break. I'll be back later.
aartaka has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
ted_wroclaw has joined #lisp
davepdotorg has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 272 seconds]
Bourne has joined #lisp
cosimone has quit [Quit: Quit.]
cosimone has joined #lisp
davepdotorg has joined #lisp
cosimone has quit [Quit: Quit.]
galex-713 has joined #lisp
cosimone has joined #lisp
ech has quit [Remote host closed the connection]
ech has joined #lisp
davepdotorg has quit [Remote host closed the connection]
srhm has joined #lisp
yitzi has quit [Quit: yitzi]
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
pyrobitz has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
galex-713 has quit [Ping timeout: 272 seconds]
cosimone has quit [Remote host closed the connection]
cosimone_ has joined #lisp
yitzi has joined #lisp
frgo_ has joined #lisp
frgo has quit [Ping timeout: 272 seconds]
EvW has joined #lisp
ljavorsk has quit [Ping timeout: 246 seconds]
davepdotorg has joined #lisp
galex-713 has joined #lisp
terrorjack has quit []
davepdotorg has quit [Ping timeout: 272 seconds]
blackadder has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
ebzzry has quit [Remote host closed the connection]
ebzzry has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzzโฆ]
terrorjack has joined #lisp
davepdot_ has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
<mseddon>
ah yes. I was trying to figure out some of the really nasty edge cases with complex opentype scripts and yick. harfbuzz is not pretty to read.
davepdotorg has quit [Ping timeout: 240 seconds]
<jackdaniel>
if I had desire to work on shaping (which is a mess as far as I can see), I'd first learn harfbuzz abstractions and then try to write a program to transcribe its rules to some parsable format
<jackdaniel>
(from inside the application -- I'm not talking about parsing the C source code)
<mseddon>
jackdaniel: it's pretty fugly, particularly when you start dealing with all the different glyph substitution algorithms. That is at least partly because the fonts themselves are quite a nightmare for scripts with complex ligatures such as arabic etc.
yitzi has quit [Quit: yitzi]
<jackdaniel>
that's why automatic approach would work best I think
<schweers>
Do I assume correctly that harfbuzz is not just difficult to understand because of its design or the fact that itโs in C++, but also because the problem is non-trivial?
<mseddon>
schweers: indeed. as you can see from that link, there are no less than 8 different glyph substitution table formats.
<jackdaniel>
schweers: yes, there are plenty of arbitrary rules in arabic/ far-east languages
<jackdaniel>
(there are also some in latin typography, but there are few)
<mseddon>
actually getting a glph renderer for truetype and type 1 fonts is pretty simple though, and kinda fun.
<schweers>
Oh boy, it does look tricky
<jackdaniel>
McCLIM has a native lisp ttf font renderer with kerning, but it does not implement shaping
<mseddon>
there is a bytecoded stack based language to render type 1 glyphs, a bit like postscript, and another, different bytecode format used for true-type font 'hinting' for low res displays, too. it's utterly insane
<jackdaniel>
otoh it is >10x faster than freetype which /does/ shaping ;)
<mseddon>
you can do simple GSUB tables pretty easily and get latin ligatures, fi ffi etc.
<jackdaniel>
there is a font format which embeds shaping information
<jackdaniel>
so there you have it, but it is not as popular as ttf
<jackdaniel>
to be more precise, >100x faster
<jackdaniel>
one order of magnitude lost
Inline has joined #lisp
<mseddon>
oh right, I think ttf still has some simple ligature substitution table only. opentype has shaping, it is even more complex than ttf itself.
<mseddon>
and then there are all the arbitrary apple specific extensions etc. etc.
<mseddon>
(to ttf)
<jackdaniel>
how to put it? embrace and extend :)
* jackdaniel
gets back to lisping
<mseddon>
:)
Stanley00 has quit []
hendursa1 has quit [Quit: hendursa1]
wsinatra has joined #lisp
hendursaga has joined #lisp
patlv has joined #lisp
shifty has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
aartaka has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
frgo_ has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
Bike has joined #lisp
contrapunctus has joined #lisp
frgo has joined #lisp
<Josh_2>
Afternoon
EvW has quit [Ping timeout: 260 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
ted_wroclaw has joined #lisp
luckless_ has joined #lisp
dbotton has joined #lisp
ted_wroclaw has quit [Client Quit]
blackadder is now known as SaganMan
midre has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
midre has joined #lisp
dbotton has quit [Quit: -a- IRC for Android 2.1.59]
wsinatra has quit [Ping timeout: 260 seconds]
frgo has quit [Remote host closed the connection]
dbotton has joined #lisp
wsinatra has joined #lisp
patlv has quit [Ping timeout: 240 seconds]
srhm has quit [Read error: Connection reset by peer]
srhm has joined #lisp
choegusung has joined #lisp
gko_ has joined #lisp
rumbler31 has joined #lisp
pyrobitz has quit [Remote host closed the connection]
<jmercouris>
Gnuxie[m]: why does the object not keep its own annotations?
mindCrime_ has joined #lisp
<Gnuxie[m]>
jmercouris: well, is there a way to do that without creating new slot-definitions and metaclasses (or creating a new implementation)?
<jmercouris>
There is not, but I am failing to see the disadvantage of creating one new slot
<Gnuxie[m]>
you're right in that I havn't spent a very long time justifying it yet
<pve>
Hello, the Smalltalk-80 "Blue book" specifies a method "become: otherObject", and I'm wondering if there is an equivalent function in CL. The method is described as follows:
<pve>
"Swap the instance pointers of the receiver and the argument, otherObject. All variables in the entire system that pointed to the receiver will now point to the argument and vice versa. Report an error if either object is a SmallInteger."
wsinatra_ has joined #lisp
<jmercouris>
you can change the types of objects at runtime
<jmercouris>
however, that is not in the spec (I think)
<jmercouris>
its reliability really depends on the implementation, I have not had good luck with it before
wsinatra has quit [Ping timeout: 256 seconds]
<beach>
jmercouris: You can change the class of a standard object.
mindCrime_ has quit [Ping timeout: 244 seconds]
<jmercouris>
Yes, I think there were some other strange things though with changing the class if I remember, had to do with specialization
<beach>
Gnuxie[m]: I don't recognize the use case. I need to read your specification a bit more.
<easye>
jmercouris: everywhere that closer-mop works, I would be expect to be able to change the types at runtime.
<jmercouris>
yes
<easye>
Debugging why one's use of MOP doesn't work is another is often my case...
<beach>
jmercouris: Though I am pretty sure there are classes that don't allow an instance of it to change its class. Let me dig up some examples.
<pve>
the best I could come up with was change-class and copying the slots, but I'm not so sure about it
* easye
finds the actual applied use of AMOP to be more subtle then it seems to be from reading the documentation.
<jackdaniel>
key-value annotation not "embedded" in the annotated object makes sense -- you don't want to clutter "someone else's" classes with your own stuff
<beach>
A class metaobject can't necessarily be used in change-class.
<beach>
"Portable programs must not call change-class to change the class of any class metaobject or to turn a non-class object into a clas metaobject"
<beach>
Same for generic functions.
<beach>
Same for methods.
<jmercouris>
I see
<beach>
Same for slot-definition metaobjects.
<beach>
And in SICL there will be plenty others, like arrays, symbols, packages, streams...
<Bike>
change-class on those is undefined in the standard anyway
<beach>
Ah, so redundant information. Thanks.
<jmercouris>
anyway to get the readme from a quicklisp system without installing said system?
v28pabcdef has joined #lisp
<jmercouris>
s/anyway/any way
<Bike>
like what, programmatically?
<jmercouris>
yes
<Bike>
i don't know if quicklisp has a way to download a system without loading it. i would imagine it does
<jmercouris>
(describe (first (ql:system-list))) leads me to believe no
<jmercouris>
the readme is certainly not in the dist itself
<jmercouris>
or the metadata that it collects for the list of systems in system-list
<Bike>
asdf might have a way to specify a readme, i forget
<Bike>
practically speaking most systems probably don't, though
<v28pabcdef>
hey guys, im getting "Failed to find the TRUENAME of /tmp/package.lisp\nNo such file or directory" when I (asdf:load-system) one of my projects i made with (quickproject:make-project). tried reinstalling SLIME but hasnt helped. anyone know?
<jmercouris>
Bike: I guess one could use: asdf:system-description
<jmercouris>
v28pabcdef: has nothing to do with slime
<v28pabcdef>
was guessing but couldnt hurt. google didnt provide many answers.
<easye>
Bike: One can scrape the URIS Quicklisp from <file:~/quicklisp/dists/quicklisp/releases.txt>
<jackdaniel>
v28pabcdef: perhaps you have loaded the asd file directly from buffer?
<v28pabcdef>
.. are you not supposed to do that? oops
<jackdaniel>
you may compile it, then it will compile and load file
<easye>
but in practice downloading and installing locally involves code loaded via ASDF, so it can't really be separated easily.
<jackdaniel>
but when you load it, it will probably take the current path
<jackdaniel>
in your case /tmp/
<jackdaniel>
so all files are assumed to be placed in that directory
Lycurgus has joined #lisp
<Gnuxie[m]>
๏ปฟjmercouris: the main problem I've faced is that it's not always straightforward to take two metaclasses that are specific to a libraries needs and you basically are at the mercy of either author as to whether they're going to be compatible or not and each author is writing a lot of code to achieve similar aims (annotate a class and its slots)
<v28pabcdef>
thanks. so whats a normal workflow then for loading a system im working on?
<Gnuxie[m]>
I don't give an example of this yet, and I suppose I really should
<easye>
And certainly for any computation Quicklisp dependencies mean ASDF dependencies, so by definition one has already invoked (ASDF:LOAD-SYSTEM :quicklisp) in the current image.
<Gnuxie[m]>
jmercouris: There is also a case where a library might want to add annotations to classes it doesn't know about in advance (anything that needs to do some kind of dynamic analysis of other objects like a profiler or something), each library doing this has to create their own incompatible API to access these annotations
<jackdaniel>
v28pabcdef: you put your source code (or symlink your project's directory) in either ~/common-lisp or ~/quicklisp/local-projects
<jmercouris>
I guess: (asdf:system-description (asdf:find-system :cl-json)) will have to do for now
<jackdaniel>
then when you do (asdf:load-system "system-name"), it will be found "automagically"
<v28pabcdef>
nice, thanks a lot.
<jackdaniel>
sure
<jmercouris>
Gnuxie[m]: but you can make a class inherit from something even if you don't know about it in advance
<jmercouris>
this is exactly the problem we had in Nyxt
<jmercouris>
absolutely convoluted I might add, but possible
<easye>
v28pabcdef: you should be able to invoke ASDF:FIND-SYSTEM on the system. Then use the generic functions ('load-op 'test-op ...) as you need them.
<easye>
As jmercouris points out, most people use convenience DEFUN entry points like ASDF:TEST-SYSTEM and ASDF:MAKE
<jackdaniel>
1) I'm jackdaniel :) 2) these are classes
<Gnuxie[m]>
jmercouris: right ok
<v28pabcdef>
\q
v28pabcdef has left #lisp ["ERC (IRC client for Emacs 26.3)"]
ted_wroclaw has joined #lisp
<Gnuxie[m]>
jmercouris: do you describe this problem with Nyxt in detail anywhere?
random-nick has joined #lisp
dominic34 has joined #lisp
dominic34 has quit [Excess Flood]
dominic34 has joined #lisp
<schweers>
Quick question: in SBCL #\Linefeed is read as #\Newline. How do I get the "\r" character?
<schweers>
Nevermind, its #\Return.
frgo has joined #lisp
frgo_ has joined #lisp
vaporatorius__ has quit [Ping timeout: 258 seconds]
aartaka_d has quit [Read error: Connection reset by peer]
frgo has quit [Ping timeout: 240 seconds]
vaporatorius has joined #lisp
yitzi has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
sm2n has quit [Remote host closed the connection]
yitzi has quit [Client Quit]
yitzi has joined #lisp
sm2n has joined #lisp
edgar-rft has joined #lisp
epony has joined #lisp
orivej has joined #lisp
Lycurgus has quit [Quit: Exeunt]
treflip has quit [Quit: WeeChat 2.6]
elflng has quit [Read error: Connection reset by peer]
elflng has joined #lisp
<_death>
Gnuxie[m]: such slot "annotations" have been called facets, like slots of a slot.. some object systems have them, and I remember the MOP book had an example of how to add basic facet support to CLOS
davepdot_ has quit [Remote host closed the connection]
davepdotorg has joined #lisp
rogersm has quit [Ping timeout: 244 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
<Gnuxie[m]>
_death: oh ok, thanks, I'll have to look into that
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
frgo has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
frgo_ has quit [Ping timeout: 240 seconds]
schweers has quit [Ping timeout: 260 seconds]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzzโฆ]
Cymew has quit [Ping timeout: 265 seconds]
theseb has quit [Quit: Leaving]
theseb has joined #lisp
borei has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
pi123 has quit [Quit: WeeChat 2.3]
mindCrime_ has joined #lisp
johnjay has joined #lisp
<eta>
hmm, does macroexpansion attempt to evaluate the body before the macro function is invoked?
<eta>
I attempted to write a macro that's called like (example-macro (1 . abc)), and it's complaining that 1 isn't a SYMBOL
paul0 has joined #lisp
_paul0 has quit [Ping timeout: 272 seconds]
<jackdaniel>
I don't understand your question
davepdot_ has joined #lisp
<beach>
eta: You had better show the code for the macro. And yes, your question is strange.
<eta>
oh wait, I just tried to make a minimal test case and I realised I'm an idiot :)
<eta>
TIL if an error occurs during macroexpansion, the traceback doesn't show the invocation of the macro function
davepdotorg has quit [Ping timeout: 265 seconds]
davepdot_ has quit [Remote host closed the connection]
random-nick has joined #lisp
<_death>
eta: such an ordering would make macros useless
<eta>
_death, yeah, thought as much :p
<Bike>
i mean the backtrace _might_ have the macro function in it, depends on the implementation
slyrus has quit [Quit: Leaving]
* eta
was using SBCL
<Gnuxie[m]>
_death: it looks like ECLOS also had a metaclass to do something similar called attributed-class too
<_death>
yep
theseb has quit [Quit: Leaving]
mindCrime_ has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
OptimusMKD has joined #lisp
starch has joined #lisp
OptimusMKD has quit [Max SendQ exceeded]
orivej has quit [Ping timeout: 272 seconds]
OptimusMKD has joined #lisp
Bumble has joined #lisp
Bumble has left #lisp [#lisp]
OptimusMKD has quit [Max SendQ exceeded]
OptimusMKD has joined #lisp
OptimusMKD has quit [Max SendQ exceeded]
OptimusMKD has joined #lisp
yokoyamachan has quit [Quit: WeeChat 2.3]
davepdotorg has joined #lisp
ted_wroclaw has joined #lisp
rumbler31 has quit [Ping timeout: 265 seconds]
rogersm has joined #lisp
jw4 has quit [Quit: tot siens]
davepdotorg has quit [Ping timeout: 246 seconds]
jw4 has joined #lisp
kaftejiman has joined #lisp
OptimusMKD has quit [Quit: Leaving]
gko_ has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
yitzi has quit [Read error: Connection reset by peer]
Lord_of_Life_ has joined #lisp
rumbler31 has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
rogersm has quit [Ping timeout: 244 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
wsinatra has joined #lisp
wsinatra_ has quit [Read error: Connection reset by peer]
rogersm has joined #lisp
choegusung has quit [Quit: leaving]
<treflip>
Does cl+ssl depend strictly on OpenSSL? It throws an error during the installation on my machine with LibreSSL, because it can't load libssl.so. Maybe I'm doing something wrong?
slyrus has joined #lisp
shangul has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
grewal has quit [Ping timeout: 260 seconds]
<_death>
libressl is not binary compatible with openssl, iirc
<treflip>
>_<
ebzzry has quit [Remote host closed the connection]
<aeth>
daphnis: Redefining things in CL:FOO is undefined behavior. This means that some implementations, like SBCL, can prevent this, such as through "package locks", like in SBCL. Redefining CL:MIN could break a bunch of macros and functions if allowed, and it would prevent optimizations for things like CL:MIN or CL:+, as well, since the function it refers to could have been runtime-redefined.
<Bike>
that shouldn't come up for MIN as a variable though.
<aeth>
daphnis: You're using CL:FOO if you're in CL-USER (the default REPL package; change this with IN-PACKAGE) or if you're in a package that USEs :CL (which is almost all of them).
frgo has quit []
<aeth>
Bike: It will come up if MIN is global, like (setf min 42) directly in the REPL, since SBCL's package lock will lock global bindings, including not-currently-defined ones, like variables.
<aeth>
This will work, though: (let ((min 0)) (setf min 42) min)
<daphnis>
aeth: thanks. i'm a complete beginner. should i type something to get out of any package? what's the right state to be in to try the examples in the book?
<aeth>
daphnis: What you're currently doing is SETF on something that is not defined in the current scope, so it attempts to SETF the global variable, which is undefined. SBCL will normally permit this anyway and set the global, but give a warning. e.g. (setf foo 42)
<aeth>
But it's rarely what you actually want to do because it'll be globally scoped and dynamically scoped.
rumbler31 has joined #lisp
<aeth>
daphnis: My guess is that there's some local variable MIN that you're supposed to be setting instead, but you're not in its scope with that SETF.
<jmercouris>
daphnis: to succinctly answer the question, work in a package of your own creation
<jmercouris>
now, it is no problem! name anything whatever you like
<aeth>
jmercouris: Working in your own package but shadowing (iirc) CL:MIN will avoid the direct problem and now you can (setf min 42) to create a dynamic global variable called min, but that's probably not the actual problem. The actual problem is probably that the SETF is outside of the scope of the local, lexical variable it was intending to set
<aeth>
But without the code, it's unclear.
edgar-rft has quit [Quit: Leaving]
<jmercouris>
yes, you are probably right, but one step at a time for the new user
<jmercouris>
they should be working in their own package anyways
<daphnis>
same warning/error comes in xyz as well
<aeth>
jmercouris: Your solution doesn't work in SBCL because it's still package locked. (defpackage aeths-package (:use :cl)) (in-package :aeths-package) (setf min 42)
<jmercouris>
daphnis: please post all of your source code
<aeth>
jmercouris: That's still setting CL:MIN
<jmercouris>
I assumed they had done (defparameter min 12)
<jmercouris>
daphnis: please use a paste service for this, do not copy it into IRC directly
<aeth>
jmercouris: It will still fail. SBCL package locks all global bindings for symbols exported from COMMON-LISP (nickname CL)
<aeth>
Even though CL itself only defines a function there.
<jmercouris>
continuation 0 :-)
<daphnis>
its just that line, an example in chapter 3: (setf min 2) [not 2 but it doesn't matter]
<jmercouris>
call it something else then
<jmercouris>
daphnis: (setf my-min 2)
<daphnis>
yeah, i was mostly curious why the book uses an example that doesn't work
<jmercouris>
it probably does work in other implementations
<aeth>
daphnis: If that's really supposed to be used at the top level with no other context, then that's just incorrect in three ways. (1) it should be called *min* because it's a global, (2) it should use DEFPARAMETER because using SETF on new variable bindings is undefined behavior, and (3) it can't be called MIN because that's undefined behavior.
<jmercouris>
what is your learning source daphnis ?
<aeth>
So one part poor style, two parts undefined behavior that doesn't have to work on all CLs (and #3 doesn't in SBCL, but #2 does)
<daphnis>
Graham's ANSI Common Lisp
<jmercouris>
what is this book?
<jmercouris>
I see, don't use this book
<jmercouris>
begin with Practical Common Lisp, Graham's book seems to be fraught with errors
<aeth>
There's probably another CL implementation where #3 works, but #2 doesn't.
<jmercouris>
probably, but why bother, who would ever suggest to just setf a top level form without having first defvar/parameter
<jmercouris>
this is a most dated way of thinking
<aeth>
It's possible that there's missing context, since we're only given one line from the book
<aeth>
(and no, the most dated way of thinking would use SETQ or even SET)
<jmercouris>
I am exaggerating when I say "most"
narimiran has quit [Ping timeout: 256 seconds]
CrazyEddy has quit [Ping timeout: 246 seconds]
liberliver has quit [Ping timeout: 265 seconds]
equwal has quit [Remote host closed the connection]
<White_Flame>
what does that measure? it doesn't come up in the first pages of the 2 search engines I've tried, searching for Common Lisp
<Hexstream>
Based on the Alexa rank.
<White_Flame>
what does that measure?
<Hexstream>
Which ostensibly measures traffic.
<_death>
it's ranked higher than those, but how do you know it's the top ranked CL site?
Lord_of_Life has quit [Excess Flood]
<White_Flame>
I think github would probably be the highest ranked CL site :-P
<Hexstream>
Because I know all the biggest Common Lisp sites and none of them outranks HexstreamSoft on Alexa.
<no-defun-allowed>
How does Alexa measure traffic?
Lord_of_Life has joined #lisp
<_death>
White_Flame: I checked github now as well, just for the kicks of it.. was surprised to learn that it's #90.. it's like the internet is populated by mostly programmers.. weird.. google is #1 and gmail is around 4K..
<Hexstream>
Various unscientific means, but there isn't really an alternative. Measurements get progressively more accurate the higher the rank is.
<White_Flame>
so how many unique visitors does your site get per month, and how does traffic get there? it just seems pretty odd, unless there's been a lot of alexa-specific optimization going on
<Hexstream>
There has been no Alexa-specific optimization whatsoever, unless by complete accident.
<White_Flame>
also, what about lispworks.com and lisp.se, which get the top search results for clhs?
<Hexstream>
6193 unique visitors to HexstreamSoft this month according to Cloudflare. Highest point was 608 unique visitors on September 1.
<_death>
you seem to be operating under the closed world assumption?
<Hexstream>
I'm operating under the best information that I have after being part of the Common Lisp community for more than a decade.
daphnis has joined #lisp
<_death>
still, I did not claim it was #1.. you can say that you are not aware of a site that outranks it
pve has quit [Quit: leaving]
<Hexstream>
Also note that gigamonkeys.com has tons of content (and traffic) unrelated to Common Lisp, but I'm still counting it as a Common Lisp site to be thorough.
<Hexstream>
Well, after investigation, not tons, and most of the site's traffic is quite probably PCL.
<no-defun-allowed>
Hexstream: do you get page view numbers?
<Hexstream>
You mean in Cloudflare analytics? I see 133496 "requests" for the month.
<Hexstream>
Maybe I should try Google Analytics again at some point, I used that billions of years ago but I had like 5 unique visitors per day.
<White_Flame>
I wonder how much of the lisp community also blocks trackers & analytics
<White_Flame>
although I presume cloudflare might have an intrinsic view regardless
<Hexstream>
Right, Cloudflare is immune to that.
<Gnuxie[m]>
hopefully most of it
<White_Flame>
yeah, I certainly do. But I guess the bump from students would likely be more similar to the general population