epony has quit [Remote host closed the connection]
<larix1>
Shinmera: I see you made the AUR package for lem. I'm building from source and when I go into "diredit" mode, I get "SDL Error (#<SDL-SURFACE ...>): Text has zero width"
<larix1>
I don't get this with the sdl2-devel package on RPM-based system, I was wondering if you know how to fix this.
<larix1>
On arch if it wasn't clear
epony has joined #commonlisp
donleo has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 260 seconds]
notzmv has joined #commonlisp
zetef has quit [Remote host closed the connection]
zetef has joined #commonlisp
zetef has quit [Read error: Connection reset by peer]
<Gojira>
earlier I was asking about binding two variables to multiple elements of a list in LOOP, such as: (loop for (element . next) in biglist do ...) however i'm getting error: "The Value [first element of biglist] is not of type LIST." (biglist is a list, per ((listp biglist) ...) and not empty, tests earlier). Anyone have a suggestion?
<Gojira>
In reading the docs on destructuring, I don't see an example of this either.
<paulapatience>
Try on instead of in.
<Gojira>
yoza! that seems to work.
<Gojira>
thanks!
<paulapatience>
Also, if you use the period, next will be the cdr rather than the following element, not sure if that's important.
<Gojira>
ah! yes it is!
<paulapatience>
You can iterate over two at a time with for ... by #'cddr
<Gojira>
yeah. looking at the output ... bunch of cdr's.
<Gojira>
okay. thanks agin.
<paulapatience>
(loop for (a b) on list by #'cddr ...)
josrr has quit [Remote host closed the connection]
<Gojira>
cadr, no?
<Gojira>
to get the element after a?
<paulapatience>
The by clause is used to advance the list
<paulapatience>
The (a b) destructuring takes care of the car, cadr stuff
<Gojira>
then what binds b to the first of the rest?
<Gojira>
ah.
<Gojira>
hmm, still getting b as cdr of biglist
<paulapatience>
You can macroexpand loop to see how it works, but it takes some getting used to
<Gojira>
loop for (el . next) on alist by #'cddr
<paulapatience>
remove rhe period
<Gojira>
that does it.
<paulapatience>
I usually refer to practical common lisp's chapter on loop when I need a reference
<paulapatience>
And also some looking at the macroexpansion
<Gojira>
I think I'm going to need to dogear that chapter :)> loop is such a black box I tend to keep my eyes averted from it.
<paulapatience>
Once you've used it a few times, the common cases become second nature
<Gojira>
no doubt.
dnhester26 has joined #commonlisp
dra has quit [Ping timeout: 246 seconds]
bilegeek has joined #commonlisp
mgl has quit [Ping timeout: 264 seconds]
kenanb has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1)]
eddof13 has joined #commonlisp
eddof13 has quit [Client Quit]
Lord_of_Life_ has joined #commonlisp
rgherdt has joined #commonlisp
eddof13 has joined #commonlisp
eddof13 has quit [Client Quit]
Lord_of_Life has quit [Ping timeout: 276 seconds]
Lord_of_Life_ is now known as Lord_of_Life
pve has quit [Quit: leaving]
dra has joined #commonlisp
NicknameJohn has quit [Ping timeout: 256 seconds]
rgherdt has quit [Ping timeout: 256 seconds]
araujo has joined #commonlisp
bilegeek has quit [Quit: Leaving]
meritamen has joined #commonlisp
yitzi has quit [Remote host closed the connection]
bubblegum has joined #commonlisp
Fare has quit [Ping timeout: 256 seconds]
dra has quit [Remote host closed the connection]
bilegeek has joined #commonlisp
rtypo has quit [Ping timeout: 268 seconds]
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
notzmv has quit [Ping timeout: 240 seconds]
meritamen has joined #commonlisp
igemnace has joined #commonlisp
notzmv has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
meritamen has quit [Quit: It's time to bed. ZZZzzz...]
tertek has quit [Quit: %quit%]
tertek has joined #commonlisp
meritamen has joined #commonlisp
<aeth>
are equalp hash tables with list keys a terrible idea?
<aeth>
I just need to see if an exact list has shown up before and if it has return the value and otherwise do a thing and store the value
<aeth>
which would suggest equalp hash table or nested hash tables
<larix>
aeth: ive just used #'equal for that when memoizing fn args
<larix>
maybe thats wrong? its worked well so far
<moon-child>
trouble with memo is you want it to be deep
<moon-child>
if I have (b c) and (a b c), the tails had better shared structure
<larix>
ok, let me test my library... I hadn't used equalp before so I didn't know to do that
<moon-child>
so you need some extra manual work
<larix>
can you show me an example of equal and equalp being different
<ixelp>
GitHub - garlic0x1/memeozi: A memoization library for Common Lisp
<jcowan>
It's really obnoxious that EQL does not imply EQUAL. It really should.
ronald has joined #commonlisp
<larix>
i suppose there are enough situations where its faster to just use eql, as im assuming they compare addresses in memory instead of whole thing
<larix>
so it makes sense, unless i misunderstand it
<jcowan>
EQL is not reliably an address check for numbers or characters
<moon-child>
numbers and characters don't have addresses
<jcowan>
EQL is identity, EQUAL and EQUALP are structural equality, EQ is a speed hack.
<moon-child>
whichi s annoying because they could have been defined to consistently behave as though they had addresses with basically no performance hit
<jcowan>
moon-child: How's that?
<moon-child>
jcowan: _basically_ the current implementation strategy
<moon-child>
semantically, you say that + etc. nondeterministically chooses whether to hash-cons its result or cons up a new one
<larix>
thinking in C style, it makes sense since comparing ints and addresses would be same
<moon-child>
but whatever result is chosen is consistent and stays the same
<masinter>
WE'
<moon-child>
so (eq a b) implies (eq a b) regardless of what a and b are
<jcowan>
Hash consing numbers is pretty expensive
<masinter>
we're using EQUALALL
<moon-child>
the implementation strategy would be
<moon-child>
fixnums are always hash consed
<masinter>
for deciding whether a variable has "changed"
<moon-child>
bignums never are
<masinter>
(EQUALALL A B) if prettyprinting would print the same string
<larix>
masinter: what are you using it for?
<larix>
"we"
<jcowan>
The trouble arises with EQUAL when you compare two circular lists. Supposing A is a circular list, then (eq a a) returns t, whereas equal does not necessarily return t
<moon-child>
,(subtypep nil (eql t))
<ixelp>
(subtypep nil (eql t)) ERROR: Too few arguments in call to #<Compiled-function EQL #x14006DFE>: ↩ 1 argument provided, at least 2 required.
<masinter>
it's tied up with HPRINT which will print circular structures
<moon-child>
,(subtypep nil '(eql t))
<ixelp>
(subtypep nil '(eql t)) => T; T
<moon-child>
seems fine to me
<bike>
"constructively implies"? is that a real term? it sounds almost real even though i just made it up
<ixelp>
Nonblocking cycle detection and iterator invalidation
<moon-child>
bike: hrm, what does it mean?
<bike>
"eql returning true constructively implies equal returns true" would mean that if eql returns true, equal actually returns, and it returns true
<moon-child>
I don't understand why 'constructively' means that there
araujo has quit [Ping timeout: 246 seconds]
<masinter>
larix for medley
<jcowan>
yes, that seems a strange use of "constructively"
<jcowan>
Scheme returns #t for (equal? a a) with two exceptions: circular objects that aren't eq?, and two NaNs
<moon-child>
cycle detection is not that hard or expensive
<moon-child>
modulo the adversarial scenario I mention in my link above
markb1 has quit [Ping timeout: 246 seconds]
<moon-child>
though that is not relevant for equal
<masinter>
KMP wrote something about EQUAL
markb1 has joined #commonlisp
<moon-child>
so did henry baker
<aeth>
larix: the problem with equal vs equalp is... equalp is case insensitive, which is probably not what you want, but equal uses eql instead of = (so the type has to match) to test numbers when it crawls through your sequences recursively, which is probably not what you want
<larix>
,(equal (float 2) 2)
<ixelp>
(equal (float 2) 2) => NIL
igemnace has quit [Quit: WeeChat 4.1.2]
<larix>
i think this is still fine for me, as a very general solution to memoization
igemnace has joined #commonlisp
<larix>
masinter: medley looks fun
<jcowan>
I would say that is what you want for memoization: 2.0 is not 2
<aeth>
I suppose it depends on what you're memoizing
<larix>
my library takes a plist of options in defmemo, so i can just add :test #'your-equal as an option
<aeth>
a lot of people are probably OK with the numeric tower of everything ending up as a long-float (which is probably just the same as a double-float) eventually, while a lot of people want their single-floats as single-floats and their integers as integers
<larix>
(defmemo (:test #'equalp) times (a b) (* a b))
<aeth>
although the former would most properly be done as, as soon as a float shows up, replace the memoized rational (integer or fraction) with a float
<aeth>
which is more complicated
<jcowan>
aeth: do you handle multiple values?
<aeth>
jcowan: with what?
<jcowan>
The nice thing about using EQUAL is that multiple arguments are handled correctly without extra ado
igemnace has quit [Remote host closed the connection]
<jcowan>
my bad, that was meant for larix
<aeth>
ah, I brought up hash tables (equal, equalp, or perhaps just nested) because I'm doing something more limited than a library
<larix>
jcowan yes, but im about to push a :test option for the defmemo so its more versatile (defaults to #'equal)
<jcowan>
I don't understand what :test has to do with returning multiple values
<larix>
oh, returning from the memo? i thought you meant passing to.
ym has joined #commonlisp
<aeth>
SPIR-V requires type metadata bound to an ID so if there's a vec3, that requires generating OpTypeVector <ID for 32-bit float> 3, which is my particular problem at the moment. I've never considered list-key hash tables before
<aeth>
This means that on the first sight of a vec3, it generates or looks up the ID for OpTypeFloat 32 and for OpTypeVector <whatever the ID is for 32-bit float> 3
<aeth>
and if it generates an ID, it also needs to generate the instruction that binds it in the SPIR-V itself
<larix>
jcowan no it does not do multiple return, I will try to add that as well
<larix>
thanks im getting good ideas here haha
<larix>
one other thing, i need to add &key &optional and &rest support
decweb has quit [Ping timeout: 260 seconds]
gilberth has quit [Ping timeout: 264 seconds]
ixelp has quit [Ping timeout: 255 seconds]
ixelp has joined #commonlisp
kenanb has joined #commonlisp
Kyuvi has quit [Ping timeout: 250 seconds]
Pixel_Outlaw has quit [Remote host closed the connection]
szkl has quit [Quit: Connection closed for inactivity]
ronald has quit [Ping timeout: 240 seconds]
azimut has joined #commonlisp
<Shinmera>
larix: no
Aesth has joined #commonlisp
rainthree has joined #commonlisp
ronald has joined #commonlisp
<hayley>
"nondeterministically chooses whether to hash-cons its result or cons up a new one" But I wanna hash-consing GC and/or copying immutable objects whenever I find it convenient.
kenanb has quit [Ping timeout: 245 seconds]
White_Flame has quit [Remote host closed the connection]
White_Flame has joined #commonlisp
jon_atack has quit [Read error: Connection reset by peer]
jonatack has joined #commonlisp
<rainthree>
beach: https://paste.rs/s2Pc0 is this similar in any way to the way Common Lisp does it?
<hayley>
Does what?
<rainthree>
the way the value is passed to the function emphasize
<hayley>
I suppose, but Common Lisp uniformly uses reference semantics, very unlike Hylo.
<rainthree>
Thanks, that's what I was trying to make clear for myself
<beach>
I don't know Hylo, but I agree with hayley that Common Lisp does it very differently.
<hayley>
beach: It uses "mutable value semantics" which is mostly value semantics, but allowing references in certain cases which cannot cause references to alias or outlive their referencees.
<beach>
rainthree: But you are using "pass by value" and "pass by reference" in a way that is not what it means, though the C++ people seem to use it your way, thereby not respecting established terminology.
<beach>
hayley: Thanks!
<beach>
rainthree: "pass by value" just means that the arguments of a function are evaluated before the function is applied. It says nothing about the nature of those values, that can be references or something else.
<beach>
I am sorry to hear that they are using it that way.
<rainthree>
haha
<beach>
rainthree: "pass by reference" is when the caller passes a reference to an object. Again, it says nothing about the nature of that object. But then, typically, you can not use an arbitrary expression as the argument. It must be what is known as an l-value.
madnificent has joined #commonlisp
<moon-child>
in some languages, if you pass something other than an lvalue, a temporary location will be created
<beach>
Though early versions of Fortran always used pass by reference, even when the argument was not an l-value. So you could do something like f(1) and then in f (not using Fortran notation) f(x) {x = 2} and from then on, 1 would be 2.
<beach>
moon-child: makes sense.
<madnificent>
Searching for common lisp things online the top hits tend to be from quickref.common-lisp.net ; I feel totally lost when arriving there. If not for quickref having arrived earlier on I'd have no idea what it would be about nor how to use what I read.
<hayley>
Quickref leaves much to be desired. Like why the hell are there sections on the files and internal definitions in my code? That's /my/ business, get your nose out of there.
<madnificent>
I _think_ I'm missing context when arriving there. Perhaps some text at the top stating that it's a library for Common Lisp which can be installed (for example through QuickLisp). Perhaps also a search for similar packages. Not sure.
<hayley>
Some of the definitions aren't even my business because I generate a whole bunch of definitions for hash consing. But I digress.
<madnificent>
Oh hayley looks like I've caught you online. Is it possible that the changes you made to luckless fix an infinite loop on insertion? Or did we just not encounter it anymore due to changed heuristics? We had a case I could reproduce with the version on QuickLisp.
<madnificent>
The castable is really nice to use.
<beach>
Quickref also seems to ignore documentation!!!
<hayley>
I don't remember, but Luckless and 42nd-at-threadmill really don't like bad hash functions which generate lots of collisions.
<hayley>
Maybe try increasing reprobe-limit in hashtable.lisp? 10 might be low; 42nd-at-threadmill goes for 256.
khrbtxyz has joined #commonlisp
<moon-child>
provable collision bounds apparently. i still don't entirely understand the math
<madnificent>
hayley: We landed at an infinite loop.
<madnificent>
(I'll search to see if I find back what exactly)
<hayley>
moon-child: That's good when you have any entropy to start with; I've had cases in one-more-re-nightmare where SBCL would generate a total of 13 hash values for something like 10,000 sets of assignments (represented as lists-of-lists).
<moon-child>
hence hash-mix so you can diy that part too
<moon-child>
only real problem is you don't get good eq hashes for arrays, or any eq hashes at all for conses, and need to reach into internals stuff for eq hashes for structs. Otoh you can diy eq hashes for structs if you know you need them, and not pay any space cost if you never ask for sbcl-internal eq hashes. so
NicknameJohn has joined #commonlisp
<hayley>
That does ring a bell. I still am guessing a bad hash function at the moment, though I'd usually (eventually) get stack overflow because of too many recursive resizes.
<moon-child>
didn't somebody make a scalable concurrent tree thing in cl? Based on that one thing by the one java guy. Ideally should be possible to fall back to that
<madnificent>
I should be able to reproduce the keys (and hashes) that were put into the system. They're strings and the strings do share some structure. I don't know the constrainst of sbcl's hash function so can't estimate.
<ixelp>
GitHub - no-defun-allowed/concurrent-hash-tables: A "portability" library for concurrent hash tables in Common Lisp
<hayley>
(Make sure you don't have Luckless or Threadmill loaded before loading that library, else the library will instead wrap those.)
<madnificent>
I'm using it as concurrent set in the case where the issue occurred. It was introduced when multiple threads were reading/writing but today there's a single thread actively writing so the specific issue doesn't matter too much. However, I'm a bit worried about the issue arrising in the same system on other castables where concurrency is an important part.
kenanb has joined #commonlisp
mgl has joined #commonlisp
<madnificent>
What do the bars in the flamegraphs of concurrent-hash-tables mean? Which color means which implementation?
<ixelp>
GitHub - scymtym/clim.flamegraph: Flamegraph-style visualization of sb-sprof results in CLIM
<hayley>
(I'm not suggesting to use Threadmill here, because it's even more picky about hash functions.)
<madnificent>
Right! I saw that graph before and it's interesting. Perhaps the concurrent-hash-tables implementation could be used to abstract over the functionality offered by the other libraries so it'd be possible to select the desired implementation fairly late in the game and perhaps use multiple implementations at runtime?
<hayley>
Right, except I haven't got a good idea for the multiple implementations part.
jonatack has quit [Read error: Connection reset by peer]
jon_atack has joined #commonlisp
Ellenor has quit [Ping timeout: 256 seconds]
szkl has joined #commonlisp
AetherWind has joined #commonlisp
_cymew_ has joined #commonlisp
dajole has quit [Quit: Connection closed for inactivity]
<beach>
rainthree: Do you still have doubts about the Common Lisp semantics?
<madnificent>
hayley: In what sense do you not have a good idea for the multiple implementations part?
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dino_tutter has joined #commonlisp
bilegeek has quit [Quit: Leaving]
<hayley>
Doing the dispatch is tricky; TYPECASE is inextensible and generic functions are slow (in current Common Lisp implementations and relative to the time taken to do hash table operations).
pve has joined #commonlisp
<madnificent>
Perhaps a typecase in a function that could be inlined? With the necessary type annotations that could fold to the specific implementation? Flexibility has a price.
<rainthree>
beach: to the friend who presented me the Hylo programming language and who said "Lisp doesn't have this, because it needs Linear Typing", I said that it implements Mutable Value Semantics, and that Lisp has that already, and I can see one difference is that in Hylo you have to use special syntax & while in Lisp it's automatic
<moon-child>
you could do it at compile time, couldn't you?
<hayley>
I could compile my own not-quite-generic functions.
<beach>
rainthree: I see.
<hayley>
rainthree: Lisp doesn't make any guarantees of lack of aliasing, so uniform reference semantics doesn't subsume mutable value semantics in that sense.
<hayley>
A wise person however said that mutation is for chumps.
<moon-child>
I mean like
donleo has joined #commonlisp
<moon-child>
have a general 'hash table' package that picks what other package to import everything from or whatever
<madnificent>
hayley: Are you eying a solution in which hash-table implementations can be added? In my head all of this was one big static implementation depending on other libarries.
<hayley>
moon-child: That's not too far off what I do now, but it doesn't allow for multiple implementations if I understand it right.
<hayley>
madnificent: Ideally yes.
<moon-child>
mmmm
<moon-child>
I mean ideally you would be able to do that, but practically, why would you want to?
<hayley>
(Though I'm not sure if the world needs another not-quite-generic-functions thing.)
<hayley>
Dare I utter the words "dependency injection" to describe that picking the implementation for another library might be useful?
<hayley>
s/might/which might/
<hayley>
I dunno. Threadmill is pretty unportable though.
<hayley>
...but that can be approached with a static approach. No time-slicing #commonlisp and university forms for me.
<rainthree>
hayley: please explain what is aliasing or give an example or expand on the idea
<hayley>
No bot. That evaluates to 2; updating the value of A causes the value of B to be updated because they are the same. A and B are said to alias.
<beach>
ixelp is here though.
<hayley>
Mutable value semantics and linear typing both make it impossible to alias.
<hayley>
beach: ixelp doesn't seem to want to evaluate my code.
<beach>
Yeah.
<hayley>
If one cannot alias, then it is easier to tell what some side effect does, but then it is trickier to construct some interesting data structures.
<beach>
rainthree: Languages without automatic memory management have a problem in that it is very hard to know how many references there are to a particular object. It might be tempting then to avoid that possibility. But that will make programming much harder.
meritamen has joined #commonlisp
<rainthree>
yes
<beach>
rainthree: Worse, some people design languages without automatic memory management because they falsely believe that automatic memory management is costly compared to manual memory management.
<beach>
rainthree: Not only are modern techniques for automatic memory management very efficient compared to manual memory management. But for large programs, modularity makes it very hard to know the number of references to an object. So people who write large applications in such languages often resort to smart pointers and reference counters.
<beach>
rainthree: And by doing that, they turn a simple assignment like (SETQ A B) which in Common Lisp often is a single register instruction, into a test and branch and function call.
<rainthree>
wow
<beach>
rainthree: With reference counters, you then first decrement the reference counter of A, then you check whether it is then zero, and if it is, you call a function to deallocate it. Then you increment the reference counter of B, and finally you assign B to A.
* moon-child
quickly throws a table cloth over those pesky write barriers
<hayley>
I'm trying to work out the rules for how I'd enrol for a parallel programming course, when I didn't do the prerequisite class and the prerequisite class is about "systems, networks and concurrency". I may either apply based on "formal learning" i.e. that I did a course on operating systems which covered much of the content, or "informal learning" i.e. I had some work experience which involved the
<hayley>
content.
<hayley>
(This becomes related to Common Lisp in the next sentence, give me a second to write it.)
<madnificent>
hayley: I think there would be a lot of value in a manual crafted library that includes what it needs at compile-time. That would greatly simplify what'd need to be built. Then perhaps be kind for PRs to add implementations.
<beach>
rainthree: My guess is that large applications in languages without automatic memory management that use this technique would be way faster if they were written in a language with automatic memory management. But since it is rare to have a large application written in two languages for comparison, the people writing those applications probably believe they made a good choice for reasons of performance.
<beach>
rainthree: Oh, and incrementing or decrementing a reference counter requires two memory operations which we try to avoid for obvious reasons.
<madnificent>
beach: I agree with you. However, it's not a stretch to want applications which consist of small parts. With many small parts memory management needn't be a problem (except it likely is, as could be proven by checking tickets about memory issues on FOSS C applications).
<hayley>
I could cite my parallel GC as work experience because the GC is a pile of concurrent algorithms and memory management, but I don't have an employer who can write a statement for me. I also need to find two referees "who can verify the experience".
igemnace has joined #commonlisp
<hayley>
beach: In my opinion, if one uses reference counting they are using (rather bad) automatic memory management.
<beach>
Absolutely.
<hayley>
madnificent: I think the issue is worse with small parts, because now you have to document which part allocates and frees what.
<beach>
hayley: But the language does not have it. The application does.
<beach>
madnificent: If it consists of small parts, you more often need to pass objects between parts. So then, either you pass the objects themselves so that you are sure that every live object has a reference count of 1, or you pass a reference.
<hayley>
(Ahem, naive reference counting, etc, you can write a good reference counter, but it looks suspiciously like a tracing GC, here is the obligatory link to the Unified Theory of Garbage Collection <https://courses.cs.washington.edu/courses/cse590p/05au/p50-bacon.pdf>)
<beach>
madnificent: In the former case, you lose because objects are larger than references to objects, and you need to copy memory. In the latter case, you get memory leaks.
<madnificent>
hayley, beach: Right. Did not consider that enough. Anyhow, regardless of the reason, searching for issues would be good proof regardless of the reason.
<beach>
I guess the extreme situation is with microservices, where you need to not only copy every object that is sent from one part to the other, but you also need to serialize those objects, thereby getting network overhead and losing object identity.
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
<hayley>
I'm still undecided on if I should apply by the formal learning route or the informal learning route; I'd appreciate if anyone wants to referee for me and my GC. I guess stylewarning is closest to being my employer?
<madnificent>
I am (not your) employer but can't consciously gauge further than the libraries I've used. I'm not at home in GC to estimate that work. Do you need an employer to motivate the informal work?
<hayley>
Looks like the formal route is going to be easier, though still messy as the courses don't match up. Never mind.
<hayley>
madnificent: The policy is that the informal learning has to be through some work experience, and I need "a statement from the employer". I guess their definition of work is that I am employed by someone.
rgherdt has joined #commonlisp
cage has joined #commonlisp
waleee has joined #commonlisp
cage has quit [Remote host closed the connection]
cage has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
NicknameJohn has quit [Ping timeout: 276 seconds]
NicknameJohn has joined #commonlisp
waleee has quit [Ping timeout: 256 seconds]
waleee has joined #commonlisp
<Shinmera>
hayley: if you need an employer reference I'd be happy to write one
waleee has quit [Ping timeout: 240 seconds]
waleee has joined #commonlisp
<hayley>
Shinmera: Thanks. At the moment I'm thinking it won't be necessary, though I get to overthink it until the university re-opens in a few days.
LispTyro has quit [Quit: leaving]
waleee has quit [Ping timeout: 252 seconds]
waleee has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
<ixelp>
About the Technical Reference | Common Lisp Docs
<beach>
I would avoid gender-specific pronouns. Rewriting the sentence instead is better.
<dnhester26>
That's a page making the intention of the technical reference clear and how it differs from the intention of the specification and novaspec
<dnhester26>
beach: which sentence?
<beach>
"If he is focused.." "but for him to read.."
<dnhester26>
beach: changed two places of compiler writers to language implementers
<dnhester26>
beach: "any conforming Common Lisp code should be able..." is replacing which sentence?
thollief has joined #commonlisp
<beach>
"any Common Lisp code should be..."
<dnhester26>
thanks
<beach>
If the code is not conforming, there is no reason to expect it to behave the same across implementations.
<dnhester26>
what should I replace "he" with? "The programmer"?
<beach>
dnhester26: I think the Common Lisp HyperSpec was also derived from the draft, but I am not entirely sure.
<beach>
dnhester26: Sure.
Aesth has quit [Read error: Connection reset by peer]
<ixelp>
CLHS: About the Common Lisp HyperSpec (TM)
<beach>
Instead of "Reading the specification is not always clear..." I would write "From reading the specification, it is not always clear..." or something like that.
<beach>
dnhester26: I am not sure about the word "specification". It is in fact a standard.
<dnhester26>
beach: "Reading..." yeah I changed that one as well before. same as you.
<dnhester26>
beach: ok so change it to standard everywhere or just in that sentence?
<beach>
At least change all places where the final version is referred to.
<dnhester26>
ok
<beach>
Those are the main things I found. I hope others will read it too.
<dnhester26>
is the section about the differences between novaspec and the technical reference correct?
<dnhester26>
thanks
<beach>
I think you need to ask gilberth about that. I haven't read up on his objectives with it.
<dnhester26>
got it
<dnhester26>
beach: oh what should I change the "he" to be? "the programmer"?
<shka>
i appreciate distinction between "tutorials" and "how to guides"
<dnhester26>
I'm not sure 100% about breaking up the explanations in their own section entirely though. I would like some level of explanations in the tutorial and reference. Though having said that I would like much more in depth explanations in this section: https://lisp-docs.github.io/docs/category/advanced-topics
<ixelp>
Advanced Topics | Common Lisp Docs
<shka>
though i found it difficult to write them separately
<dnhester26>
shka: yeah, I haven't added a how To guides section because I thought we should first work on the tutorial and technical reference, but if you see here: https://lisp-docs.github.io/ in the bottom left of the 4 cards I list How To Guides
<ixelp>
Common Lisp Docs | Common Lisp Docs
<dnhester26>
Ideally someone will make guides for developing a web app, a game, etc from beginning to finish just like they have in racket and other languages
<dnhester26>
The cookbook has great info, but a lot of times things are missing, he uses different libraries in different sections so you don't really get to have a full how to guide using the same libraries, and it can be hard as a newbie
<shka>
can this be edited like wiki?
ronald has quit [Ping timeout: 260 seconds]
random-nick has joined #commonlisp
yitzi has joined #commonlisp
glaucon has joined #commonlisp
<dnhester26>
shka: I thought so with the Edit botton at the bottom of each page, but someone else told me that it forks the project. I did it and it was edited but it can be because I'm in the repo. Can you please try and see if it's complicated. I think it just gives the change to be accepted as a fork, but you don't actually have to leave the browser. Not sure though
<dnhester26>
I can add you as a member of the repo if it's easier for you
<shka>
dnhester26: is it static page?
<shka>
oh, apparently there is a server
<shka>
drakonis: can't edit, github gives me 404
<shka>
dnhester26: sorry, tab failure :-)
<dnhester26>
hm, let me check
<dnhester26>
oh
<dnhester26>
ok
olnw has joined #commonlisp
<shka>
i wonder if it would be possible to get permission to put "practical common lisp" here in a new section "books"
<shka>
but that would be a bit much perhaps
<olnw>
dnhester26: There's a typo here: "the consecuences of those aspects"
<dnhester26>
shka: it's a markdown page
<dnhester26>
olnw: thanks! fixing it now
<olnw>
Also, same sentence, it says "tha language".
<dnhester26>
shka: I wanted to add CLtL2 there making it much easier to read, but we need to ask permission from HP or some other big company who bought the last copyright owner
<dnhester26>
olnw: thanks, not sure how I missed those after having read it myself like 3 times. You have a good eye!
<ixelp>
Introduction | Common Lisp (New) Language Reference
<shka>
dnhester26: got it
<dnhester26>
shka: however the whole page is static, the markdown is compiled to html when deploying to github pages
<shka>
yes, i was simply wondering how search works
<shka>
but i know now
szkl has quit [Quit: Connection closed for inactivity]
NicknameJohn has joined #commonlisp
NicknameJohn has quit [Remote host closed the connection]
zxcvz has joined #commonlisp
lucasta has joined #commonlisp
epony has quit [Remote host closed the connection]
dino_tutter has quit [Ping timeout: 256 seconds]
mgl has joined #commonlisp
azimut has joined #commonlisp
<olnw>
dnhester26: It appears that, in the footer, "Why Lisp" and "Getting Started" don't link to the correct pages.
<dnhester26>
olnw: thanks, will take a look now
cage has quit [Quit: rcirc on GNU Emacs 29.1]
kevingal has joined #commonlisp
notzmv has quit [Ping timeout: 256 seconds]
<dnhester26>
olnw: just changed the footer, thanks! :D
<olnw>
Sure.
<olnw>
I have a few more typos for you.
<olnw>
About the Technical Reference: "is a consice"
<olnw>
About Common Lisp Docs: "manking", "categorize and provied", "documentaion"
<olnw>
Also should capitalise initial letter of "lisp" in the first sentence.
<olnw>
And there is a page titled "Why Common Lisp for Begineers?"
<mfiano>
Seems like a spell checker would go a longer way than a grammar checker like languagetool, while you're writing this, which should be easy to come by with your environment.
kenanb has quit [Ping timeout: 260 seconds]
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
Fare has joined #commonlisp
mgl has quit [Ping timeout: 276 seconds]
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
I just use flyspell-mode in Emacs when I write text.
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
meritamen has joined #commonlisp
meritamen has quit [Client Quit]
<dnhester26>
olnw: wow! thanks for all those fixes! just went through them now
<dnhester26>
mfiano, yeah, thanks, as I was fixing those reading the comments I downloaded languagetool in vscode :D I didn't realize how many typos the spellchecker usually gets for me haha
gilberth has joined #commonlisp
epony has joined #commonlisp
meritamen has joined #commonlisp
olnw has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1.90)]
<Shinmera>
Colleen (and thus logging) will be offline for a bit due to server maintenance.
<aeth>
OK, so it's time to discuss what will be in the next standard
<beach>
What makes you conclude that?
<aeth>
(joke)
josrr has quit [Remote host closed the connection]
<beach>
Ah!
<aeth>
what other kind of secret knowledge can we discuss while unlogged?
<Shinmera>
how to win big
josrr has joined #commonlisp
Guest28 has joined #commonlisp
Inline has quit [Quit: Leaving]
Inline has joined #commonlisp
meritamen has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
epony has quit [Read error: Connection reset by peer]
Guest28 has left #commonlisp [#commonlisp]
Aesth has joined #commonlisp
beach` has joined #commonlisp
yitzi has quit [Ping timeout: 252 seconds]
yitzi has joined #commonlisp
beach has quit [Killed (NickServ (GHOST command used by beach`!~user@2a01:cb19:683:8800:b958:dc9a:50bc:d28))]
beach` is now known as beach
glaucon has quit [Read error: Connection reset by peer]
epony has joined #commonlisp
lucasta has quit [Quit: Leaving]
NicknameJohn has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
chomwitt has joined #commonlisp
dino_tutter has joined #commonlisp
cage has joined #commonlisp
pfdietz has quit [Quit: Client closed]
Fare has quit [Ping timeout: 260 seconds]
pfdietz has joined #commonlisp
traidare has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
Gleefre has quit [Remote host closed the connection]
kevingal has quit [Ping timeout: 256 seconds]
Gleefre has joined #commonlisp
Shinmera has quit [Ping timeout: 255 seconds]
Colleen has quit [Ping timeout: 260 seconds]
seok has quit [Quit: Client closed]
seok has joined #commonlisp
notzmv has joined #commonlisp
kevingal has joined #commonlisp
glaucon has joined #commonlisp
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
dnhester26 has joined #commonlisp
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Shinmera has joined #commonlisp
Colleen has joined #commonlisp
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
jmdaemon has quit [Ping timeout: 260 seconds]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
zxcvz has quit [Quit: zxcvz]
eddof13 has joined #commonlisp
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
enzuru has quit [Ping timeout: 260 seconds]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
pfdietz has quit [Quit: Client closed]
pfdietz has joined #commonlisp
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
eddof13 has quit [Ping timeout: 256 seconds]
Colleen has joined #commonlisp
Colleen has quit [Client Quit]
Colleen has joined #commonlisp
szkl has joined #commonlisp
<Shinmera>
Colleen: hello
<Colleen>
Hi!
<Shinmera>
should be all back, sorry for the downtime
<aeth>
It was a good opportunity for completely off-the record, entirely unlogged wisdom about Common Lisp that will never be uttered again.
Pixel_Outlaw has joined #commonlisp
Kyuvi has quit [Quit: Client closed]
bubblegum has quit [Read error: Connection reset by peer]
bubblegum has joined #commonlisp
<Equill>
We really should have done something with it, now you put it that way.
zxcvz has joined #commonlisp
enzuru has joined #commonlisp
zxcvz has quit [Client Quit]
azimut has joined #commonlisp
traidare has quit [Ping timeout: 240 seconds]
rainthree has quit [Read error: Connection reset by peer]
dinomug has joined #commonlisp
chomwitt has quit [Ping timeout: 268 seconds]
dajole has joined #commonlisp
zetef has joined #commonlisp
azimut_ has joined #commonlisp
dnhester26 has quit [Read error: Connection reset by peer]
rainthree has joined #commonlisp
azimut has quit [Ping timeout: 240 seconds]
zxcvz has joined #commonlisp
chomwitt has joined #commonlisp
dnhester26 has joined #commonlisp
josrr has quit [Remote host closed the connection]
josrr has joined #commonlisp
AetherWind has quit [Quit: leaving]
Fare has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
Jach has quit [Ping timeout: 240 seconds]
Jach has joined #commonlisp
jon_atack has quit [Ping timeout: 252 seconds]
cage has quit [Quit: rcirc on GNU Emacs 29.1]
Fare has quit [Ping timeout: 252 seconds]
glaucon has quit [Quit: WeeChat 3.5]
jonatack has joined #commonlisp
tyson2 has joined #commonlisp
rainthree has quit [Ping timeout: 260 seconds]
khrbtxyz has quit [Ping timeout: 268 seconds]
azimut_ has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 245 seconds]
rainthree has joined #commonlisp
khrbtxyz has joined #commonlisp
azimut has joined #commonlisp
Fare has joined #commonlisp
zxcvz has quit [Quit: zxcvz]
Fare has quit [Ping timeout: 245 seconds]
yitzi has quit [Remote host closed the connection]
azimut has quit [Ping timeout: 240 seconds]
azimut_ has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
yitzi has joined #commonlisp
igemnace has quit [Remote host closed the connection]
szkl has quit [Quit: Connection closed for inactivity]
zxcvz has joined #commonlisp
zxcvz has quit [Client Quit]
kevingal has quit [Ping timeout: 260 seconds]
dnhester26 has joined #commonlisp
rainthree has quit [Ping timeout: 255 seconds]
kenanb has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
_cymew_ has quit [Ping timeout: 252 seconds]
attila_lendvai has quit [Ping timeout: 240 seconds]
<Shinmera>
there'll be future opportunities, I'm sure
ym has quit [Ping timeout: 252 seconds]
bubblegum has quit [Ping timeout: 252 seconds]
Inline has quit [Quit: Leaving]
zetef has quit [Remote host closed the connection]
bubblegum has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
seok has quit [Ping timeout: 250 seconds]
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
kevingal has joined #commonlisp
tyson2 has joined #commonlisp
mgl has joined #commonlisp
thollief has quit [Quit: Leaving]
bubblegum has quit [Ping timeout: 276 seconds]
bubblegum has joined #commonlisp
notzmv has joined #commonlisp
bubblegum has quit [Ping timeout: 256 seconds]
pve has quit [Quit: leaving]
mariari has quit [Ping timeout: 268 seconds]
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
Kyuvi has joined #commonlisp
Aesth has joined #commonlisp
pfdietz has quit [Quit: Client closed]
mariari has joined #commonlisp
random-nick has quit [Ping timeout: 260 seconds]
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #commonlisp
araujo has joined #commonlisp
attila_lendvai has joined #commonlisp
Inline has joined #commonlisp
pfdietz has joined #commonlisp
random-nick has joined #commonlisp
Kyuvi has quit [Quit: Client closed]
NicknameJohn has quit [Ping timeout: 268 seconds]
attila_lendvai has quit [Ping timeout: 256 seconds]
Gleefre has quit [Remote host closed the connection]
Gleefre has joined #commonlisp
attila_lendvai has joined #commonlisp
Fare has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
mgl has quit [Ping timeout: 255 seconds]
shka has quit [Ping timeout: 276 seconds]
Fare has quit [Ping timeout: 245 seconds]
Fare has joined #commonlisp
yitzi has quit [Remote host closed the connection]
attila_lendvai has quit [Ping timeout: 260 seconds]
akoana has joined #commonlisp
dino_tutter has quit [Ping timeout: 256 seconds]
kevingal has quit [Ping timeout: 268 seconds]
kevingal_ has joined #commonlisp
Fare has quit [Ping timeout: 255 seconds]
Fare has joined #commonlisp
<Gojira>
another question about loop ... I want to use the counter generated from (loop for counter from 0 ...) outside the loop. However if I (let ((counter 0)) (loop ...)) the value is always zero after the loop. Any suggestions??
pfdietz has quit [Quit: Client closed]
Fare has quit [Ping timeout: 260 seconds]
azimut_ has quit [Ping timeout: 240 seconds]
<moon-child>
(let ((counter 0)) (loop while (< counter whatever) do (incf counter) ...) ...)
<moon-child>
alternately, (loop for counter from 0 ... finally (use counter here))
<aeth>
or finally (return counter)
<aeth>
need to return two things? finally (return (values result counter))
<aeth>
though does this introduce an off-by-one issue between implementations? when the counter stops at n, is it specified what it must be?