I feel like you haven't met a lot of Go programmers in that case. The
programmers I have met who use Go or are interested in it are often genuinely
good programmers. Of course there are "crowd" followers in any language as
popular in Go but Go is not a "Blub" language nor does it attract Blub
programmers.

Do I as a Go programmer sometimes wish that Go had feature X. Of course I do! I
want that feature when I want that feature. But, I find Go to occupy an extremely
practical position in my personal programming language continuum do to its
fairly unique mix of features. Note, it is not the features themselves that are
unique many languages individually have them. Indeed, they often also include
features I miss in Go. Rather, it is the particular mixture which is useful.

EDIT: To respond directly to the Blub article.

Features pg calls out for LISP:

Garbage collection, introduced by Lisp in about 1960, is now widely
considered to be a good thing. Runtime typing, ditto, is growing in
popularity. Lexical closures, introduced by Lisp in the early 1970s, are
now, just barely, on the radar screen. Macros, introduced by Lisp in the mid
1960s, are still terra incognita.

Go score card:

Garbage Collection [x]
Runtime Typing [p]*
Lexical Clusures [x]
Macros [ ]

* Go has some dynamic typing capabilities but nothing like Python or LISP.
Many would consider that a "good thing". It partially depends on what you
are doing.

Go has a 3/4 on the score card of features. Macros are of course enormously
useful but also very difficult to shoe horn into a c-family language properly
since they need to be expanded at compile time (unless you just go ahead and
embed you compiler backend into the runtime system of your language. That would
be kinda of crazy/awesome but you could do it). Rust has of course proven the
utility of such a choice.

I can't speak for pg, but Go has many fantastic features and is not a Blub. The
features which are missing are not, by and large, features of LISP.

EDIT 2: To add some more fuel to this fire...

pg concludes the article with:

During the years we worked on Viaweb I read a lot of job descriptions. A new
competitor seemed to emerge out of the woodwork every month or so. The first
thing I would do, after checking to see if they had a live online demo, was
look at their job listings. After a couple years of this I could tell which
companies to worry about and which not to. The more of an IT flavor the job
descriptions had, the less dangerous the company was. The safest kind were
the ones that wanted Oracle experience. You never had to worry about those.
You were also safe if they said they wanted C++ or Java developers. If they
wanted Perl or Python programmers, that would be a bit frightening-- that's
starting to sound like a company where the technical side, at least, is run
by real hackers. If I had ever seen a job posting looking for Lisp hackers,
I would have been really worried.

Note, he explicitly says here: not all languages are the same. He would
worry when a company wanted Python programmers. Why? Because to him Python
mixture of features represented a nice chunk of what LISP is providing him.
Let's do another score card:

Python Score Card

Garbage Collection [x]
Runtime Typing [x]
Lexical Clusures [x]
Macros [ ]*

* It is somewhat possible through black magic hackery to create an AST level
macro in Python. It is messy. It is cool. It's kinda crunky. And I am not
sure anyone has ever seriously used this ability. It certainly isn't main
stream. Checkout https://github.com/lihaoyi/macropy for inspiration.

Norvig agrees with this assessment: http://norvig.com/python-lisp.html . Given
that many people are ok with moving from Python to Go
<https://www.reddit.com/r/golang/comments/2aup1g/why_are_peop...
it seems reasonable to conclude that Go is an exceptible replacement for Python.
Something no one has concluded about Java (for instance).

Therefore, I believe pg would have been equally worried or almost as concerned
about Go programmers as Python programmers.