When plenty of other languages have zero cost associated ANY cost is too much unless you want people to read about and adopt alternative choices in the time required for someone to justify the company making a purchase.

I think you're misunderstanding the point and confusing standards with documentation.

Standards are for one very narrow group of people: compiler writers. If you're not a compiler writer, you have zero reason to buy the official standard document. And if you are a compiler writer, well, it would be very bizarre to choose your target language based on the price of its spec!

Please note that the final draft of the standard is published for free on that website.

ISO Prolog (ISO/IEC 13211) doesn't have a free standard and it has hurt the Prolog language immeasurably. In this case the last freely available draft is quite different from the final standard, which makes the situation worse because not everyone is aware of this.

I have noticed a lot of Prolog programmers don't know what's in the standard and what's not - you routinely see answers given on SO that are implementation dependent when they could easily have been expressed in strictly conforming ISO Prolog.

Of course, you can get pirated versions of ISO/IEC 13211-1 and 13211-2 but even saying these exist probably makes me complicit in piracy, let alone suggesting they should be widely shared in the Prolog community. The 3 technical corrigenda that update 13211-1 are freely available[0], or at least ISO allows you to "Preview" the whole document in each case.

[0] https://www.iso.org/standard/21413.html

I would put that on the implementations not following the standard rather than the availability of the standard. How many C# devs out there have read their ISO standard?

not sure about Prolog, but afaik compiler writers are usually very good about following the standards (and they reference the standards consistently when discussing (potentially) semantic bugs). In general I think its safe to trust that any given compiler (tries to) follows the standards strictly; and then implement extensions on top.

And extensions are fine. They might be syntactic sugar, or specific hacks, or strange DSLs or whatever. Convenient, if you know you're targetting a single compiler. But you can still write standards-compliant code, when necessary.

But if the compiler doesn't make it explicitly clear, and the standards aren't easily available, then you now have people using extensions without realizing it, and if you tell them you're using an extension, there's nowhere to point to as proof. If you're trying to write code successfully against two different compilers, and get different results, there's nowhere to point to to show that compiler A has the incorrect response. Instead you file against both and assume they have access to the standard.

Also afaik C# only really runs against a single compiler (mono, i think?), doesn't it? So it makes sense that community doesn't bother with the standard; you're not writing cross-compiler-compatible code, so whatever works on mono is the standard (in practice).

The same is true for python, ruby, haskell, etc. There's practically only one compiler in existence (that you care about); those implementations are the standard, regardless of any ISO standard.

But you look at the C and C++ community, and half the SO answers directly reference the standard, despite presumably being mere "users" of the language. Because when many compiler implementations exist (and used), then extensions are much less viable, and the standards are extremely important

And afaik, CL is one of those languages with multiple major compilers, and thus an easily available standard is important.

Interesting.

Fortunately for ANSI CL the last freely available draft is language-technically not different from the published standard.

It's definitely also useful to have standards documentation lookup integrated into an IDE - which I use a lot for CL. Especially since there are versions in different formats (TeX, HTML, Info files, PDF, ...)

This assumes that nobody ever wants to drill down to figure out why their app doesn't work.

Its similar to imagining nobody who uses an app could ever benefit from having access to the source.

Lisp suffers a bit from being too early to the party. When someone wants to learn a new programming language (one that's not literally a new one), there is usually a single obvious canonical implementation (most likely already available on all Unix-like machines) hosted on [language].org, with a set of documents that describe it.

Lisp is (and many other pioneering languages are) no such beast. Lisp.org is McCarty's page (peace be upon Him) and my Linux laptop has about half a dozen dialects of Lisp: Emacs Lisp one or two CL's, Guile, Clojure and Scheme. I love it, but it wasn't easy to start.