[mycl]

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

[stonemetal]

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?

[setr]

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.

[lispm]

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, ...)