[bad_user]

As some people like to point out, I'd also like to remind that in 1968 Algol had:

    - user defined record types
    - user defined sum types
    - switch/case statement with support for sum types
    - unified syntax for value and reference types
    - closures with lexical scoping
    - parallelism support
    - multi-pass compilation

Given that many mainstream languages don't offer even what Algo68 had, I personally understand how a Go developer might thing that "nothing is new under the sun" since the 80's. After all, Go ignores all progress in programming languages for the last 40 years.

I recommend watching "Growing a Language", a legendary presentation by Guy Steele: https://www.youtube.com/watch?v=_ahvzDzKdB0

I do love the attempts of Go developers to rationalize Go's choices. But in the end it will end up being a hated language, universally recognized as a net negative in the industry. But that won't stop the working programmer from doing the same mistake again and again.

[mixedCase]

>After all, Go ignores all progress in programming languages for the last 40 years.

I've seen this meme being spouted so much every time Go's mentioned it's ridiculous.

No, piling up feature upon feature is not progress otherwise we wouldn't be using anything but C++.

Go is a language you pick for the right situation. If it's not enough for what you're trying to do, go for a different one instead of trying to expand in the wrong direction leaving you with warts, like Java's done, C++'s done, Python, JavaScript etc... which you will have to end up avoiding in order to write performant and clear code, counting on luck not to have to deal with code that abuses those features to create anti-pattern upon anti-pattern.

[AdieuToLogic]

  >After all, Go ignores all progress in programming
  languages for the last 40 years.

  I've seen this meme being spouted so much every
  time Go's mentioned it's ridiculous.

Is it a meme when it is true? To support this question, witness the statements of Rob Pike[0] below.

---

Regarding the utility of supporting first-order functions[1]:

  I wanted to see how hard it was to implement this sort
  of thing in Go, with as nice an API as I could manage.
  It wasn't hard.

  Having written it a couple of years ago, I haven't had
  occasion to use it once. Instead, I just use "for" loops.

  You shouldn't use it either.
 

---

Regarding progress in programming languages[2]:

  One thing that is conspicuously absent is of course
  a type hierarchy. Allow me to be rude about that for
  a minute.

And[2]:

  Programmers who come to Go from C++ and Java miss
  the idea of programming with types, particularly
  inheritance and subclassing and all that. Perhaps
  I'm a philistine about types but I've never found
  that model particularly expressive.

---

The part about "particularly inheritance and subclassing and all that" is ironically a meme spouted by Go's community so much it is, if you'll pardon my borrowing your description, ridiculous. For the curious, there are many community "Go-isms" explainable by the Pike talk[2].

Even a casual reading of the "list of significant simplifications in Go"[1] (35 in all) is enough to reasonably support the "ignoring all progress" position.

Of course, YMMV.

0 - https://en.wikipedia.org/wiki/Go_(programming_language)

1 - https://github.com/robpike/filter

2 - https://commandcenter.blogspot.com/2012/06/less-is-exponenti...

[mixedCase]

> [1]:

I don't see how that helps your argument. For loops are more than enough for that task, it's easily readable and universal.

And Go does support first-class and higher order functions so not sure what you're talking about here.

> [2]:

How's ditching inheritance in favor of composition "ignoring the last 40 years"? It's the biggest example together with goroutines that proves that phrase is a meme, and that we've learnt a lot on typing best practices as an industry over the past couple decades.

And as an added bonus, another thing that's a good example of Go actually looking back and improving upon what's been done before is the select statement. Most popular languages fall through by default with the switch statement.

Outside of examples on the internet, I can't recall right now the last time I've seen a switch statement in the wild that didn't break at the end of every case. Making the case (pun not intended) for a fallthrough statement and having switch/select break by default.

[danmux]

I'm no language historian, but I did limit my timeframe to my personal experience of 36 years of development for a reason. There was necessarily incredible research in the 20 years prior to that, which made it into useable languages, of course this is no hard cutoff, just an arbitrary personal choice, and I am happy to stand corrected. My point was simply that at least in the languages that make up 2σ of all code running in production in the last 20-30 years very rarely do they include "language" features that did not appear as truly innovative sometime before that. It may be argued that simply including some prior research in a useable language is innovative, or that the incremental improvements are themselves innovation, but then we are bogged down in semantics. In summary every time anyone in recent years has claimed to be innovating in language design someone else counters it with prior art, and that Go never pretended to be innovative in this direction. Given the lineage, and experience of the Golang authors it is more likely, in general that they considered and rejected, rather than ignored.

[snaky]

> Go ignores all progress in programming languages for the last 40 years

That's not unusual at all. Look what Fran Allen said about previous language from those guys - https://news.ycombinator.com/item?id=11578995

[jacques_chester]

The most famous writeup, discussed here when it emerged 7 years ago, was "Go vs Brand X".

http://cowlark.com/2009-11-15-go/

[_ak]

And where is Algol now? It's dead. Theoretical superiority on paper is worth absolutely nothing when there is no usable implementation for modern computing environments out there.

This article was written to make Go look bad and unoriginal, but it inadvertently proves that Go is Algol's legitimate successor exactly _because_ it has all these features _and_ a working implementation that is available for wide variety of architectures and operating systems.

[jacques_chester]

I think Pascal (and Modula and Oberon) are more legitimate successors to Algol.

I wasn't aware that all of those working implementations had stopped working.

Popularity is just one dimension a language can be placed on. Java utterly dominates the volume of new code being written in regular industry and has most likely done so for the entire lifetime of Go.

And this says little about their other relative virtues.

[snaky]

I think it could easily be INTERCAL (and INTERCAL#, of course) dominating the world now, if Sun, IBM and other giants choose it instead of Java and pushed it with the same amount of force.

[_ak]

Fun fact: one of the Oberon-2 developers is also one of the principal developers of Go. Learn your PL history.