Nitpick - Go is very much an OO language. Almost everything is done using objects. It has a different way of handling inheritance however - it makes a different decision in the "Composition over inheritance" debate.

https://en.wikipedia.org/wiki/Composition_over_inheritance

I've found that there is no real standard definition of what OOP is and people get very angry when you say Go is OOP but it doesn't have inheritance. YMMV though.

As far as Alan Kay is concerned (always a pretty good yardstick)

> OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late binding of all things.

Yeah, I like this posting from him http://c2.com/cgi/wiki?AlanKayOnMessaging

Golang is the best. And this is a really amazing thing.

Golang does Pseudo OO like Motif. The added value is the composition which is amazing.

Not to start a flamewar or anything, but what about clojure (or any lisp for that matter, I just like the CLJ ecosystem) doesn't vibe with your 'minimal syntactic sugar' and other requirements?

Oh, don't mistake my comment for favorable opinion. I only wrote a few hundred lines of Go in my life. It worked well for the particular problem I was solving, but I'm really more of a C/C++ guy.

The problem with lisps is that you need to know lisp, and relatively few people do. It also requires a different approach to program design. It may or may not be a better approach, but the fact is, that's not what most people are trained for.

In contrast, go is imperative through and through, and its syntax is similar enough to C that people find it easy to adapt to it.

The little secret of Lisp is that you can use it pretty much as an imperative language, even though it also enables functional programming. The main barrier is that Lisp is taught as a functional programming language, and many believe that this is the only way you should use it.

Go tends to emphasize the simple, imperative way to get a computational thing done. It goes so far as to never hide a for loop from you. I'm not experienced with lisp, but from reading sicp, it seems to be a paradigm built on creating stacked layers of syntactical sugar (dsls).

No floats?

No functional programming, or language features borrowed from there.

Which is kind of a shame, since many of those concepts would complement the strengths of Go quite nicely -- i.e., a pure goroutine that had no visible side effects apart from channel activity would help enable automatic remote execution in a cluster.