

Multiple Programming Language Implementations - This Annoys Me the Most - mudge
http://nickmudge.info/index.php?post=126

======
gdp
You use a language with no particular specification and no particular set
purpose, and are surprised that it changes between point releases? I guess
he's never used PHP then.

Languages divide reasonably cleanly into those that have no published
semantics (formal or informal), those that have a published informal
semantics, and those that have a published formal semantics. I use 'semantics'
here to cover both the usual meaning and the semantic interpretation of
syntactic constructs. On this continuum, there are very few with published
formal semantics, and a huge number with no published specification
whatsoever. I've heard proponents of these languages actually claim that "the
compiler is the specification".

So if you use a language where the world view is "we'll do whatever the hell
we want and then the compiler decides what it means!" then you can hardly
complain when it all gets a bit confusing. That's reason number 77,061 for me
not using Ruby.

------
mahmud
If you find "multiple programming language implementations" annoying, chances
are their respective communities find _you_ annoying. For your own sanity, if
something seems annoying to you, ask if there is a different way to do things.

His problems with Lisp and Ruby are contradictory: he hates Ruby because it
has two competing major versions, not realizing what he wants is a _standard_
specification of the language. Yet his problem with Lisp is that "it's big on
reference documents".

Pick any Common Lisp implementation and any incompatibility with the
specification is a bug.

~~~
brianto2010
I agree with some of the things you said. However,

> _Yet his problem with Lisp is that "it's big on reference documents"_

I didn't interpret it that way... Mudge said:

> _"Most prominently I think of Lisp when I think of multiple implementations.
> Maybe it's not so much all the parentheses that have caused Lisp not to
> become a popular mainstream programming language. Maybe it has more to do
> with the lack of a single solid implementation. I also noticed that Lisp
> seems to be big about written language standards, while more popular
> programming languages more or less follow a reference implementation as the
> standard for the language."_

He said that lisp's lack of a _single solid implementation_ is/maybe the cause
of its unpopularity. Also, he mentioned 'big on reference documents' as an
afterthought (because of the word 'also', I think). The 'reference documents'
part is not his main argument.

> " _If you find 'multiple programming language implementations' annoying,
> chances are their respective communities find you annoying._ "

Its more like an expression of frustration. I doubt a community would find him
annoying unless he _actively and incessantly_ bugs them about his
'annoyances'.

~~~
mahmud
Lisp is a family of languages, so how can there be a single standard
implementation? If he means Common Lisp, well, CL is a standardized
programming language; is there a de facto C implementation? how about C++? Of
course not! GCC is the most widely available implementation, but you would be
foolish to write GCC-dependent C code.

SBCL is not harder to install than GCC, in fact, it's trivial to install and
upgrade (compared to the nightmare that is a libc upgrade) but you don't see
people complaining about C being hard to install or lacking a canonical
implementation.

~~~
gdp
But people _do_ write GCC-dependent code. In fact, they will even write GCC
_version_ dependent code, to the tune of "this will not compile correctly with
GCC 4.x.x, you will need to use 2.95.26.2.3.5.1"

And given that the complaint was specifically levelled against Ruby, for the
most part, it seems to be making one specific point:

If your language is specified by the existence of a single reference
implementation, and you keep changing that reference implementation, then
that's equivalent to the _language_ continually changing, which is a fair
criticism, I think, particularly when it breaks backwards compatibility or
continually deprecates features used in production code (requiring an endless
cycle of rewrites, or maintenance of some older branch of the implementation).
This sort of behaviour would certainly strike me as "annoying", but that's
essentially what you get when you commit yourself to using a product which
makes no attempts to standardise, and which lacks large commercial customers
who would place pressure on the software vendor to keep backwards-
compatibility as a priority.

------
jacquesm
This is a 'feature', not a bug.

It may annoy you, but then you should not try to get your head wrapped around
languages that are currently probably best described as 'moving targets'.

Older, more mature languages, like COBOL, PASCAL, LISP and C (to a lesser
extent C++) do not suffer from this. Conversely, they're slow to adapt to
changing requirements and that is why if you wish to do clever stuff with a
minimum of verbosity you find yourself on the bleeding edge of language
development.

It's a price you are either willing to pay, or you'll be finding yourself
writing a lot of code in a language that was not well geared towards the age
of the internet.

PHP, Ruby, Python, Scala and even Java are under active development so you
will have to make choices about which version you are going to stick to for
the time being.

~~~
gdp
> _PHP, Ruby, Python, Scala and even Java are under active development so you
> will have to make choices about which version you are going to stick to for
> the time being._

Java probably shouldn't be included in that list. The language is evolving,
but I don't think I've encountered anything that breaks between three major
version releases (i.e. Java 1.4 code works equally well with a compiler for
Java 5 or 6). All of the other languages (possibly with the exception of
Scala, which I have little knowledge of) have radically changed the core
language between _minor_ releases. The PHP project has been particularly
guilty of changing subtle semantic interpretations of things in releases that
are on the order of "bug fix" updates.

This is the fundamental difference to me. Java has a published spec for the
core language. Some of the libraries might move around a little bit, but even
most of those are relatively stable.

There are plenty of _other_ reasons not to use Java, but if you want a
language that is fundamentally "stable", then Java is best-of-breed.

~~~
jacquesm
OPs main gripe is that he has to choose between versions.

For java that's relatively easy (latest stable release I would say), but even
then you run the risk of forcing your users to upgrade from an older version,
so the choice issue persists.

