...I haven't looked at it since it was first released. It wasn't easy to use on Windows at the time.

I don't understand why Ada never took off, it had everything you find in the modern languages: tasks, low-level bit manipulation, OS assembly language interface, packages, OOP-like, even its own build dependency system. And I just like it.

What about the merits of individual languages and why they dont stick?

A language where source input formatting and indentifier casing affects the semantics is just pukeware. Like Python.

Well, it looks like quite a large community of Python programmers totally disagree. But you must know better...

I don't understand why Ada never took off

I mostly agree, however, I don't really feel it's performance is so poor as to be an issue.

I do really miss the union type, however, if I remember correctly there was issues with the gc (and interfaces can cover in language needs to a certain extent.)

This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

"This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

... C++ is a monster...

"[q]This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

"... C++ is a monster...

This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

Programming is a complex subject and invariably all languages that start as a movement against complex languages, end up getting complex as people realize that the features the designers left out actually exist for a reason.

The way Go throws out the window two decades of language research made me change from a initial contributor to the language, to a D/Rust fan.

"[q][q]This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

"[q]... C++ is a monster...

"This complaint can also be addressed to Ada, Modula-3, Delphi, C#, Scala, Lisp, Haskell, ML...

"Programming is a complex subject and invariably all languages that start as a movement against complex languages, end up getting complex as people realize that the features the designers left out actually exist for a reason.

The way Go throws out the window two decades of language research made me change from a initial contributor to the language, to a D/Rust fan.

"Please correct me if I'm wrong, but you give me the impression that in your view, programming languages are mostly interchangeable, to the point their features might easily be enumerated in a standard way and compared using giant tables without further information."

To a certain extent yes.

In proper software engineering you should learn about algorithms, data structures and ways to organize code (OO, FP, Logical, ...).

Then you need to have a broad set of programming languages background that enables you for a given project, using all requirements as input, to choose the best set of languages/libraries/operating systems to solve the real problem the customer has.

Getting to know every detail of a specific tool leads to useless specialization.

I would rather leave my plumbing repairs to a plumber that knows how to get the job done, than to one that knows every detail of the special wrench XTY.

Actually Go is even worse than that if we take in consideration that languages like Turbo Pascal or Ada are older than 20 years, and already have richer data structures available.

Go lacks:

- exceptions;

- enumerations;

- generic types;

- direct use of OS APIs, without the need of writing wrappers;

- currently only static compilation is available;

- due to static compilation only model, there are issues with 3rd party code;

- no support for meta-programming;

- rich set of available libraries;

- the PR about go routines and channels, usually forgets to mention that similar features do exist as libraries for other languages

Go is just a re-branded Limbo (Plan9) with ADT data type exchanged by interfaces.

I bet that if it wasn't being developed at Google, almost no one would care for it. All their Go PR talks is about showing web applications that can be equality easily done in any available mainstream language.

Try to find one that is not about doing REST APIs, or front-ends with Ajax calls.

Anyone with a proper compiler design curriculum in their CS degree can easily find languages/libraries that offer similar features.

Most people at Lambda the Ultimate seem to agree with this, http://lambda-the-ultimate.org/node/4554

Lisp is a "simple" language because it uses just 1 form (s-expressions.)

In your plumber example, if my plumber had bought one of these fancy keys with a free-wheeling functionality, I would expect him to know how to use it, and not spend a few minutes randomly flinging it around or parsing the manual while trying to find the switch that toggles fastening mode and loosening mode. I agree, however, that he doesn't need to know the specific procedure required to clean and grease it in order to do that job.

Can we agree on that ?

"
Go lacks:

- exceptions;

"- enumerations;

"- generic types;

"- direct use of OS APIs, without the need of writing wrappers;

"- currently only static compilation is available;

"- due to static compilation only model, there are issues with 3rd party code;

"- no support for meta-programming;

"- rich set of available libraries;

"- the PR about go routines and channels, usually forgets to mention that similar features do exist as libraries for other languages

"Go is just a re-branded Limbo (Plan9) with ADT data type exchanged by interfaces.

"Anyone with a proper compiler design curriculum in their CS degree can easily find languages/libraries that offer similar features.

Panic/recover usually lead to very ugly code similar to setjmp/longjmp and resemble poor man's exceptions.

[W]ith iota you are not able to offer what real enumerations mean.

Strong type assignment between enumerations,

conversion to string, parse string to enumeration

cycle between enumeration values

compile exceptions when not all cases are referred in switch/case statements.

"Although the specific feature is not there, Go provides generics-like features through interfaces. The language FAQ states that they will add some if someone can clearly point out why they are needed and how they are worth the complexity cost : http://golang.org/doc/go_faq.html#generics
"

Generics-like features through interfaces don't work for primitive types. Plus you get performance hit when casting everywhere.

Taking Delphi as example, you are able to bind directly to the OS API, while in Go you need to write a wrapper using the CGO tool, which requires a C compiler to compile the generated wrapper.

"Same in C/++ to the best of my knowledge, and that never prevented them from being largely successful. Dynamic compilation is only useful in some specific use cases, such as when the code is supposed to run on heterogenous architectures and cannot be easily recompiled after development. "

All commercial C++ compilers offer dynamic compilation as well. I was using it with Turbo C++ 3.1 back in 1996.

[D]ue to static compilation only model, [...] [y]ou cannot make use of LGPL libraries.

"See comment on generic types above."

How does this apply to meta-programming?

"There's already quite a bit of packages available for such a young language, if you ask me, and the use of a standard package manager makes it easier to deal with third-party libraries than in, say, C."

Sure, but why should I try to convince our customers to allow us to use Go over the plethora of options we have already available today?

"[Features similar to goroutines and channels] exist elsewhere indeed, go simply acknowledges their importance in today's programming landscape and thus propose a standard, well-integrated, less cumbersome way to use them.

It's as if you said that C++ is a garbage-collected language because there are C++ libs that implement garbage collection. Sure, C++ *can* be garbage-collected, but it is not a standard part of the language, students do not learn it, those who learn it as part of their work will often separately use gazillions of different, incompatible libraries... And I guess you see where I'm going from there."

Bad example. C++11 has a garbage collection API for compiler vendors to implement their own GC.

A proper GC might be part of C++17 standard.

"I don't know much about Limbo, but if it was a fine language recycling ideas from it sounds sensible. No need to reinvent the wheel every time."

May be, on the other hand, it looks like the authors are not willing to learn anything else and do not assume the world has moved on.

"
"Anyone with a proper compiler design curriculum in their CS degree can easily find languages/libraries that offer similar features."
Such as ? (Genuine question)"

- Modules (available since Modula-2)
- goroutines (Tasks, Actors, Fibers, Asynch)
- Channels (Events, Actors, Queues)
- Interfaces (Protocols, Structural Typing, Dynamic Types)

"Panic/recover usually lead to very ugly code similar to setjmp/longjmp and resemble poor man's exceptions.

"[W]ith iota you are not able to offer what real enumerations mean.

Strong type assignment between enumerations,

"conversion to string, parse string to enumeration

"cycle between enumeration values

"Generics-like features through interfaces don't work for primitive types. Plus you get performance hit when casting everywhere.

As for the performance cost of interfaces, I don't see why it should be much different from that of templating,

"Taking Delphi as example, you are able to bind directly to the OS API, while in Go you need to write a wrapper using the CGO tool, which requires a C compiler to compile the generated wrapper.

By more modern, I mean that like other recent languages, Go learns from common C/++ dev mistakes and prevents them, with safe pointers and arrays, a "defer" keyword for resource release, modules rather than duplicated prototypes in headers, range-based fors, message passing for inter-thread communication...

However, unlike other modern languages, Go does not fully jail developers into what is considered safe behaviors. As an example, facilities for arbitrary pointer manipulation, required for low-level work, are provided, only put aside with a big warning next to them.