libera/#commonlisp - IRC Chatlog

4:26:04 aeth are equalp hash tables with list keys a terrible idea?

4:30:04 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

4:30:15 aeth which would suggest equalp hash table or nested hash tables

4:31:29 larix aeth: ive just used #'equal for that when memoizing fn args

4:31:37 larix maybe thats wrong? its worked well so far

4:32:52 moon-child trouble with memo is you want it to be deep

4:33:18 moon-child if I have (b c) and (a b c), the tails had better shared structure

4:33:35 larix ok, let me test my library... I hadn't used equalp before so I didn't know to do that

4:33:42 moon-child so you need some extra manual work

4:40:19 larix can you show me an example of equal and equalp being different

4:40:25 larix is it when classes are used?

4:41:36 moon-child ,(mapcar #'funcall '(equal equalp) '("a" "a") '("A" "A"))

4:42:15 larix oh, so equal is correct for true equality here

4:42:51 larix or, the more accurate equality in this situation assuming i want "a" != "A"

4:42:52 moon-child depends entirely on what you mean by 'true equality'

4:43:00 larix yeah, sorry thats vague, haha

4:43:32 larix but yeah i will keep using #'equal for my memoize lib

4:43:46 larix https://github.com/garlic0x1/memeozi

4:45:39 jcowan It's really obnoxious that EQL does not imply EQUAL. It really should.

4:46:39 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

4:47:09 larix so it makes sense, unless i misunderstand it

4:47:54 jcowan EQL is not reliably an address check for numbers or characters

4:48:43 moon-child numbers and characters don't have addresses

4:48:56 jcowan EQL is identity, EQUAL and EQUALP are structural equality, EQ is a speed hack.

4:49:13 moon-child whichi s annoying because they could have been defined to consistently behave as though they had addresses with basically no performance hit

4:49:35 jcowan moon-child: How's that?

4:49:58 moon-child jcowan: _basically_ the current implementation strategy

4:50:15 moon-child semantically, you say that + etc. nondeterministically chooses whether to hash-cons its result or cons up a new one

4:50:20 larix thinking in C style, it makes sense since comparing ints and addresses would be same

4:50:26 moon-child but whatever result is chosen is consistent and stays the same

4:50:35 masinter WE'

4:50:38 moon-child so (eq a b) implies (eq a b) regardless of what a and b are

4:50:41 jcowan Hash consing numbers is pretty expensive

4:50:44 masinter we're using EQUALALL

4:50:54 moon-child the implementation strategy would be

4:50:57 moon-child fixnums are always hash consed

4:51:01 masinter for deciding whether a variable has "changed"

4:51:01 moon-child bignums never are

4:51:33 masinter (EQUALALL A B) if prettyprinting would print the same string

4:52:14 larix masinter: what are you using it for?

4:52:21 larix "we"

4:52:37 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

4:53:08 moon-child ,(subtypep nil (eql t))

4:53:10 masinter it's tied up with HPRINT which will print circular structures

4:53:14 moon-child ,(subtypep nil '(eql t))

4:53:35 moon-child seems fine to me

4:53:51 bike "constructively implies"? is that a real term? it sounds almost real even though i just made it up

4:53:57 moon-child (modulo https://outerproduct.net/trivial/2023-11-29_nonblocking-cycles.html, but)

4:54:12 moon-child bike: hrm, what does it mean?

4:55:00 bike "eql returning true constructively implies equal returns true" would mean that if eql returns true, equal actually returns, and it returns true

4:55:39 moon-child I don't understand why 'constructively' means that there

4:59:28 masinter larix for medley

5:03:25 jcowan yes, that seems a strange use of "constructively"

5:04:13 jcowan Scheme returns #t for (equal? a a) with two exceptions: circular objects that aren't eq?, and two NaNs

5:05:14 moon-child cycle detection is not that hard or expensive

5:05:23 moon-child modulo the adversarial scenario I mention in my link above

5:05:34 moon-child though that is not relevant for equal

5:06:07 masinter KMP wrote something about EQUAL

5:07:41 moon-child so did henry baker

5:07:54 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

5:09:13 larix ,(equal (float 2) 2)

5:10:27 larix i think this is still fine for me, as a very general solution to memoization

5:13:39 larix masinter: medley looks fun

5:16:06 jcowan I would say that is what you want for memoization: 2.0 is not 2

5:17:24 aeth I suppose it depends on what you're memoizing

5:18:23 larix my library takes a plist of options in defmemo, so i can just add :test #'your-equal as an option

5:18:36 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

5:19:10 larix (defmemo (:test #'equalp) times (a b) (* a b))

5:19:24 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

5:19:32 aeth which is more complicated

5:21:12 jcowan aeth: do you handle multiple values?

5:24:16 aeth jcowan: with what?

5:25:42 jcowan The nice thing about using EQUAL is that multiple arguments are handled correctly without extra ado

5:30:05 jcowan my bad, that was meant for larix

5:30:27 aeth ah, I brought up hash tables (equal, equalp, or perhaps just nested) because I'm doing something more limited than a library

5:31:43 larix jcowan yes, but im about to push a :test option for the defmemo so its more versatile (defaults to #'equal)

5:32:24 jcowan I don't understand what :test has to do with returning multiple values

5:32:46 larix oh, returning from the memo? i thought you meant passing to.

5:33:01 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

5:33:43 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

5:34:25 aeth and if it generates an ID, it also needs to generate the instruction that binds it in the SPIR-V itself

5:39:50 larix jcowan no it does not do multiple return, I will try to add that as well

5:40:00 larix thanks im getting good ideas here haha

5:40:43 larix one other thing, i need to add &key &optional and &rest support

7:22:13 Shinmera larix: no

7:39:16 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.

8:22:23 rainthree beach: https://paste.rs/s2Pc0 is this similar in any way to the way Common Lisp does it?

8:25:05 hayley Does what?

8:25:06 rainthree the way the value is passed to the function emphasize

8:26:18 hayley I suppose, but Common Lisp uniformly uses reference semantics, very unlike Hylo.

8:27:05 rainthree Thanks, that's what I was trying to make clear for myself

8:30:13 beach I don't know Hylo, but I agree with hayley that Common Lisp does it very differently.

8:31:47 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.

8:32:09 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.

8:32:27 beach hayley: Thanks!

8:33:15 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.

8:33:25 rainthree they are using it that way, I only copy pasted what they said, and I hope to learn better the concepts and the right definitions. I am reading http://metamodular.com/Software-engineering/uniform-reference-semantics.html

8:33:45 beach I am sorry to hear that they are using it that way.

8:33:54 rainthree haha

8:35:08 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.

8:36:40 moon-child in some languages, if you pass something other than an lvalue, a temporary location will be created

8:36:59 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.

8:37:14 beach moon-child: makes sense.

8:37:42 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.

8:39:19 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.

8:39:30 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.

8:42:31 hayley Some of the definitions aren't even my business because I generate a whole bunch of definitions for hash consing. But I digress.

8:43:13 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.

8:44:03 madnificent The castable is really nice to use.

8:44:10 beach Quickref also seems to ignore documentation!!!

8:44:24 hayley I don't remember, but Luckless and 42nd-at-threadmill really don't like bad hash functions which generate lots of collisions.

8:46:18 moon-child https://0x0.st/HEmo.txt or so

8:47:01 hayley Maybe try increasing reprobe-limit in hashtable.lisp? 10 might be low; 42nd-at-threadmill goes for 256.

8:47:23 moon-child provable collision bounds apparently. i still don't entirely understand the math

8:47:35 madnificent hayley: We landed at an infinite loop.

8:47:48 madnificent (I'll search to see if I find back what exactly)

8:47:59 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).

8:48:48 moon-child hence hash-mix so you can diy that part too

8:49:20 madnificent hayley: The code path goes (setf gethash) -> put-if-match -> %put-if-match -> copy-slot-and-check -> %help-copy -> copy-slot -> %put-if-match.

8:50:30 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

8:50:41 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.

8:53:00 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

8:53:08 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.

8:53:24 hayley moon-child: ctrie? https://github.com/danlentz/cl-ctrie

8:53:25 moon-child martin thompson I think

8:53:40 moon-child I think so

8:54:18 moon-child oh not martin thompson? hrm. must be misremembering

8:54:23 madnificent This is not on a huge castable. I'd estimate something in [10-50] items.

8:57:33 hayley Depending on what performance you need, the "fallback" sharded table in https://github.com/no-defun-allowed/concurrent-hash-tables might be good enough for now.

8:58:13 hayley (Make sure you don't have Luckless or Threadmill loaded before loading that library, else the library will instead wrap those.)

9:00:46 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.

9:05:19 madnificent What do the bars in the flamegraphs of concurrent-hash-tables mean? Which color means which implementation?

9:07:25 hayley They're different threads in one program, from an older version of <https://github.com/scymtym/clim.flamegraph>. The picture compares sharding to using one lock, and nothing of other implementations. However https://raw.githubusercontent.com/telekons/42nd-at-threadmill/master/Documentation/performance.png compares implementations; sure, it doesn't make sharding look very good.

9:10:37 hayley (I'm not suggesting to use Threadmill here, because it's even more picky about hash functions.)

9:10:47 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?

9:13:46 hayley Right, except I haven't got a good idea for the multiple implementations part.

9:35:33 beach rainthree: Do you still have doubts about the Common Lisp semantics?

9:37:38 madnificent hayley: In what sense do you not have a good idea for the multiple implementations part?

9:41:04 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).

9:47:32 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.

9:47:56 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

9:48:05 moon-child you could do it at compile time, couldn't you?

9:48:36 hayley I could compile my own not-quite-generic functions.

9:49:15 beach rainthree: I see.

9:49:20 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.

9:49:43 hayley A wise person however said that mutation is for chumps.

9:49:57 moon-child I mean like

9:50:14 moon-child have a general 'hash table' package that picks what other package to import everything from or whatever

9:50:33 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.

9:50:52 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.

9:51:04 hayley madnificent: Ideally yes.

9:51:11 moon-child mmmm

9:51:26 moon-child I mean ideally you would be able to do that, but practically, why would you want to?

9:51:34 hayley (Though I'm not sure if the world needs another not-quite-generic-functions thing.)

9:52:57 hayley Dare I utter the words "dependency injection" to describe that picking the implementation for another library might be useful?

9:53:03 hayley s/might/which might/

9:53:31 hayley I dunno. Threadmill is pretty unportable though.

9:54:00 hayley ...but that can be approached with a static approach. No time-slicing #commonlisp and university forms for me.

9:54:02 rainthree hayley: please explain what is aliasing or give an example or expand on the idea

9:54:33 hayley rainthree: ,(let* ((a (list 1)) (b a)) (setf (first a) 2) (first b))

9:55:40 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.

9:56:08 beach ixelp is here though.

9:56:17 hayley Mutable value semantics and linear typing both make it impossible to alias.

9:56:32 hayley beach: ixelp doesn't seem to want to evaluate my code.

9:57:00 beach Yeah.

9:58:00 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.

10:00:42 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.

10:01:27 rainthree yes

10:01:31 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.

10:03:30 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.

10:04:25 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.

10:05:39 rainthree wow

10:06:11 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.

10:06:20 moon-child ACTION quickly throws a table cloth over those pesky write barriers

10:08:28 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

10:08:34 hayley content.

10:08:43 hayley (This becomes related to Common Lisp in the next sentence, give me a second to write it.)

10:08:47 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.

10:08:57 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.

10:11:51 beach rainthree: Oh, and incrementing or decrementing a reference counter requires two memory operations which we try to avoid for obvious reasons.

10:12:25 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).

10:12:43 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".

10:13:56 hayley beach: In my opinion, if one uses reference counting they are using (rather bad) automatic memory management.

10:14:08 beach Absolutely.

10:14:15 hayley madnificent: I think the issue is worse with small parts, because now you have to document which part allocates and frees what.

10:14:21 beach hayley: But the language does not have it. The application does.

10:14:56 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.

10:14:59 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>)

10:15:39 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.

10:20:12 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.

10:20:29 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.

10:25:09 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?

10:31:02 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?

10:31:08 hayley Looks like the formal route is going to be easier, though still messy as the courses don't match up. Never mind.

10:32:35 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.

11:32:08 Shinmera hayley: if you need an employer reference I'd be happy to write one

11:36:31 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.

11:56:28 shka https://www.youtube.com/watch?v=fytGL8vzGeQ one of the mighty bald lispers giving interview :)

11:57:21 beach Oh, it's up! Great!

12:09:40 jcowan beach: 1 = 2 was never part of the Fortran language, it was a bug in an earlh Fortran compiler.

12:10:16 jcowan Wely

12:10:37 jcowan argh, fingers not working. "early"

12:16:25 puke ** NICK Guest5388

12:16:25 pyooque ** NICK puke

12:16:52 puke ** NICK Guest1942

12:16:52 Guest5388 ** NICK puke

12:17:50 puke ** NICK Guest9345

12:17:50 Guest1942 ** NICK puke

12:32:43 dnhester26 hi beach, good afternoon. Would you mind taking a look at this and could you let me know if I should change anything or I made mistakes? https://lisp-docs.github.io/docs/about/reference#but-why-arent-there-a-bunch-of-spec-projects-already

12:33:46 beach Looking now...

12:34:01 dnhester26 thanks

12:34:52 madnificent That youtube video was an interesting watch.

12:35:00 beach I think it's "for whom".

12:35:35 dnhester26 haha thanks, changing that now

12:36:27 beach I would generalize "compiler writers" to "language implementers".

12:37:11 beach And I would say "any conforming Common Lisp code should be able..."

12:38:00 beach dnhester26: There is no reason to exclude other #commonlisp participants from the proofreading.

12:38:10 dnhester26 sorry

12:38:34 dnhester26 everyone: can you guys help proof reading for both meaning and grammar? https://lisp-docs.github.io/docs/about/reference#but-why-arent-there-a-bunch-of-spec-projects-already

12:38:54 beach I would avoid gender-specific pronouns. Rewriting the sentence instead is better.

12:39:01 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

12:39:37 dnhester26 beach: which sentence?

12:40:25 beach "If he is focused.." "but for him to read.."

12:40:56 dnhester26 beach: changed two places of compiler writers to language implementers

12:41:16 dnhester26 beach: "any conforming Common Lisp code should be able..." is replacing which sentence?

12:41:30 beach "any Common Lisp code should be..."

12:41:35 dnhester26 thanks

12:41:54 beach If the code is not conforming, there is no reason to expect it to behave the same across implementations.

12:43:21 dnhester26 what should I replace "he" with? "The programmer"?

12:43:26 beach dnhester26: I think the Common Lisp HyperSpec was also derived from the draft, but I am not entirely sure.

12:43:39 beach dnhester26: Sure.

12:45:05 dnhester26 beach: yeah you are right, it's only based on the standard but it's not actually the standard: https://www.lispworks.com/documentation/HyperSpec/Front/Help.htm#Authorship

12:48:33 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.

12:49:29 beach dnhester26: I am not sure about the word "specification". It is in fact a standard.

12:51:33 dnhester26 beach: "Reading..." yeah I changed that one as well before. same as you.

12:52:24 dnhester26 beach: ok so change it to standard everywhere or just in that sentence?

12:52:53 beach At least change all places where the final version is referred to.

12:53:16 dnhester26 ok

12:54:21 beach Those are the main things I found. I hope others will read it too.

12:56:05 dnhester26 is the section about the differences between novaspec and the technical reference correct?

12:56:09 dnhester26 thanks

12:57:18 beach I think you need to ask gilberth about that. I haven't read up on his objectives with it.

12:57:55 dnhester26 got it

12:59:34 dnhester26 beach: oh what should I change the "he" to be? "the programmer"?

13:02:46 beach Sounds good.

13:02:53 Shinmera "they" and "you" also work fine

13:03:15 shka dnhester26: you familiar with https://novaspec.org/cl/ ?

13:03:16 Shinmera maybe not in this specific instance, but for gender-neutrality

13:03:46 beach shka: If you read that page, you see that the answer is "yes".

13:04:08 shka i've seen the page

13:04:28 shka oh, right

13:04:37 shka novaspec to be specific was mentioned there

13:06:38 dnhester26 shka yeah: please read: https://lisp-docs.github.io/docs/about/reference#but-why-arent-there-a-bunch-of-spec-projects-already explaining what the difference is, and please let me know if I made any errors or I should change anything in that document :D

13:07:28 dnhester26 shka sorry, just read the rest of the messages and saw beach already answered

13:10:49 shka dnhester26: on unrelated note, this page looks quite nice, what have you used?

13:11:03 shka Docusaurus

13:11:06 dnhester26 shka: docusaurus.io

13:11:06 shka got it!

13:11:40 dnhester26 thanks :D though I take no more credit than choosing a nice library

13:11:43 shka awesome, it even adjusts to low screen resolution

13:12:36 dnhester26 I think the search is quite cool, although maybe a bit slow since it's hosted for free

13:12:40 shka dnhester26: you want to follow diataxis framework?

13:12:54 dnhester26 shka: what is that?

13:13:03 shka so the answer is "no" :D

13:13:10 shka https://diataxis.fr/

13:13:26 shka it is documentation writing… strategy?

13:13:28 dnhester26 oh

13:13:34 dnhester26 just googled it

13:14:14 shka a sort of documentation writing principles

13:14:23 dnhester26 Yeah! I read about it a while back here: https://documentation.divio.com/

13:14:46 shka it looked like it :-)

13:14:57 dnhester26 shka: look https://lisp-docs.github.io/docs/about there's a link. the picture looks similar so I assume it's the same idea

13:15:20 shka yes

13:15:26 shka that's why i asked

13:16:34 shka i appreciate distinction between "tutorials" and "how to guides"

13:16:58 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

13:17:11 shka though i found it difficult to write them separately

13:18:10 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

13:18:40 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

13:19:25 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

13:20:59 shka can this be edited like wiki?

13:26:10 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

13:26:29 dnhester26 I can add you as a member of the repo if it's easier for you

13:27:00 shka dnhester26: is it static page?

13:28:02 shka oh, apparently there is a server

13:28:13 shka drakonis: can't edit, github gives me 404

13:28:31 shka dnhester26: sorry, tab failure :-)

13:28:36 dnhester26 hm, let me check

13:28:39 dnhester26 oh

13:28:40 dnhester26 ok

13:30:33 shka i wonder if it would be possible to get permission to put "practical common lisp" here in a new section "books"

13:30:47 shka but that would be a bit much perhaps

13:30:49 olnw dnhester26: There's a typo here: "the consecuences of those aspects"

13:34:37 dnhester26 shka: it's a markdown page

13:34:56 dnhester26 olnw: thanks! fixing it now

13:35:53 olnw Also, same sentence, it says "tha language".

13:36:30 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

13:37:18 dnhester26 olnw: thanks, not sure how I missed those after having read it myself like 3 times. You have a good eye!

13:38:11 dnhester26 shka: the text is basically markdown see the tip (gree box) here: https://lisp-docs.github.io/cl-language-reference/ for the syntax note and links

13:39:32 shka dnhester26: got it

13:40:31 dnhester26 shka: however the whole page is static, the markdown is compiled to html when deploying to github pages

13:40:50 shka yes, i was simply wondering how search works

13:41:07 shka but i know now

14:22:23 olnw dnhester26: It appears that, in the footer, "Why Lisp" and "Getting Started" don't link to the correct pages.

14:23:08 dnhester26 olnw: thanks, will take a look now

14:35:21 dnhester26 olnw: just changed the footer, thanks! :D

14:36:00 olnw Sure.

14:36:09 olnw I have a few more typos for you.

14:36:15 olnw About the Technical Reference: "is a consice"

14:36:15 olnw About Common Lisp Docs: "manking", "categorize and provied", "documentaion"

14:36:15 olnw Also should capitalise initial letter of "lisp" in the first sentence.

14:37:16 olnw And there is a page titled "Why Common Lisp for Begineers?"

14:38:09 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.