What’s this
This repository is a list of articles that complain about golang’s imperfection.
Motivation
Seems like complaining about go’s flaws is becoming a trend. Any newbie must have a chance to read all the go-is-bad arguments before they go too far. So here it is.
What it’s for
This repo is not aimed to offend or insult someone (at least not more than each author does it in its article), especially golang itself, its authors and the community. It is for educational purpose only. Any contributor can have an absolutely different point of view.
I don’t think anyone would deny that go has weaknesses: it certainly has. But how do you know, is it really a language design flaw or is it just you, doing something completely wrong? This list here to help you quickly answer the question.
How to use it
You’re writing some code. And suddenly you understand you need something that language can’t give you. You go here and check if you’re the one with that issue or not. If it’s a common issue, it’ll be here. Then you decide what to do: choose another tool for your task or go find a better solution or a workaround.
The List
- https://cowlark.com/2009-11-15-go/ (David Given, 2009)
- c-style
- poor design
- no constructors
- no user-type iteration
new and make instead of one- stuck in 70’s
- no OOP
- too simple / lack of syntactic sugar
- https://dzone.com/articles/i-don’t-much-get-go (Jon Davis, 2010)
- no language interoperability (only C)
- no versioning model
- no OOP
- has pointers
- no semicolons at line endings
- no
this
- no function/operator overloading
- no exceptions
- https://uberpython.wordpress.com/2012/09/23/why-im-not-leaving-python-for-go/ (Yuval Greenfield, 2012)
- error handling
- stuck in 70’s
panic instead of exceptions
- http://www.darkcoding.net/software/go-lang-after-four-months/ (Graham King, 2012)
- un-googlable name
- stuck in 70’s
- no exceptions
- is compiled
- too young
- http://ridiculousfish.com/blog/posts/go_bloviations.html (ridiculousfish, 2012)
- c-style
- no unused imports
- bad unicode support
- no asserts
- http://magicmakerman.blogspot.ru/2013/07/why-googles-go-programming-language.html (Magic Maker Man, 2013)
- no OOP
- no asserts
- has pointers
- weird mascot (gopher)
- http://how-bazaar.blogspot.ru/2013/04/the-go-language-my-thoughts.html (Tim Penhey, 2013)
- error handling
- inconvenient
range
- no generics
- http://corte.si/posts/code/go/go-rant.html (Aldo Cortesi, 2013)
- http://blog.mattbasta.com/things_that_make_me_sad_in_go.html (Matt Basta, 2014)
- project layout is bad
- can’t import packages relatively
- different build approaches
- no sugar for slices
- lack of basic data structures
- https://rule1.quora.com/Golang-Not-yet (Jordan Zimmerman, 2014)
- no decent IDE
- GOPATH is a mess
- pointers are a mess
- upper-case/lower-case scoping is bad
- hidden types
- immature GC
- hard to extend
- no exceptions
- no generics
- bad dependency management
- http://yager.io/programming/go.html (Will Yager, 2014)
- no generics
- no function/operator overloading
- nil as a failure marker
- type inference is too simple
- no immutables
- no pattern matching
- https://www.upguard.com/blog/our-experience-with-golang (Mark Sheahan, 2014)
- no decent IDE
- error handling
- unexpected variable shadowing
- no generics
- not-so-obvious slices behaviour
- http://dtrace.org/blogs/wesolows/2014/12/29/golang-is-trash/ (Keith Wesolowski, 2014)
- the worst compiler toolchain ever
- psuedointellectual arrogance of Rob Pike and everything he stands for
- confusing and undebuggable
- http://www.yinwang.org/blog-cn/2014/04/18/golang (Wang Yin, 2014)
- confusing/stupid syntax
- immature toolchain
- immature GC
- no generics
- multiple return values have no type checking
- cumbersome interface
- goroutine is not original and revolutionary
- defer is abused
- stuck in Unix thinking
- summary: not elegant as Python, not strong as Java
- https://kaushalsubedi.com/blog/2015/11/10/golang-sucks-heres-why/ (Kaushal Subedi, 2015)
- no generics
- slow json parsing
- bad dependency management
- no subpackages
- http://spaces-vs-tabs.com/4-weeks-of-golang-the-good-the-bad-and-the-ugly/ (Freddy Rangel, 2015)
- not-so-obvious slices behaviour
- error handling
- hard to test, hard to mock
- http://www.evanmiller.org/four-days-of-go.html (Evan Miller, 2015)
- no unused imports
- too opinionated
- poor std math lib
- weird mascot (gopher)
- http://nomad.so/2015/03/why-gos-design-is-a-disservice-to-intelligent-programmers/ (Gary Willoughby, 2015)
- too simple / lack of syntactic sugar
- no generics
- bad dependency management
- stuck in 70’s
- http://tmikov.blogspot.com/2015/02/you-dont-like-googles-go-because-you.html (Tzvetan Mikov, 2015)
- designed for stupid people
- too verbose
- no ternary operator
- no macros or templates
- can’t change hash function in maps
- unwieldy to code new collections
- no function overloading
- can’t declare/validate implements interface
- no virtual functions
- case defined exports is bad
- http://valuedrivenit.blogspot.ru/2015/12/to-go-language-is-mess.html (Cliff Berg, 2015)
- un-googlable name
- confusing/stupid syntax
- polymorphism is broken
- compilation rules are too confining
- designed for stupid people
- package mechanism is broken
- http://blog.goodstuff.im/golang (David Pollak, 2015)
- no immutables
- too simple / lack of syntactic sugar
- confusing/stupid syntax
- too opinionated
- error handling
- stuck in 70’s
- no generics
- upper-case/lower-case scoping is bad
- no
map/reduce/filter
- http://byrd.im/go-is-poor/ (Ian Byrd, 2015)
- not-so-obvious slices behaviour
- nil interfaces are not entirely nil
- unexpected variable shadowing
- no first-class support of interfaces
- questionable compiler rigidity
- go generate is a quirk
- https://blog.plan99.net/modern-garbage-collection-911ef4f8bd8e#.62yek82xg (Mike Hearn, 2016)
- misleading marketing around garbage collector
- garbage collector is nothing new; concurrent mark/sweep from the '70s
- garbage collector requires implicit (hidden) tradeoffs
- garbage collector optimized for pause times at the cost of other desirable gc features
- http://www.jtolds.com/writing/2016/03/go-channels-are-bad-and-you-should-feel-bad/ (JT Olds, 2016)
- channels are slow
- channel API is inconsistent
- https://medium.com/@rgausnet/3-reasons-why-go-isnt-the-perfect-language-yet-25e0da5ec04c (Ryan Gaus, 2016)
- not stable
- no
map/reduce/filter
- bad dependency management
- https://www.teamten.com/lawrence/writings/why-i-dont-like-go.html (Lawrence Kesteloot, 2016)
- upper-case/lower-case scoping is bad
- case defined exports is bad
- no first-class support of interfaces
- no exceptions
- difficult to generate code automatically
- no ternary operator
- sort.Interface approach is clumsy
- no versioning model
- import-based vendoring is terrible
- no generics
- https://awalterschulze.github.io/blog/post/sum-types-over-multiple-returns/ (Walter Schulze, 2017)
- no sum types
- no algebraic data types
- multiple return parameters are overrated
- http://sitr.us/2017/02/21/changes-i-would-make-to-go.html (Jesse Hallett, 2017)
- no non-nullable types
- error handling
- no generics
- no tagged unions
- no first-class tuple
- concurrency and parallelism are mixed
- https://grimoire.ca/dev/go (Owen Jacobson, 2018)
- hostile to developer ergonomics
- too opinionated
- package mechanism is broken
- GOPATH is a mess
- error handling
Reverse complaints index
It’s a reverse complaints index, generated by https://github.com/ksimka/go-is-not-good/blob/master/generator.go (thanks to @capoferro)
- GOPATH is a mess
new and make instead of one
panic instead of exceptions
- bad dependency management
- bad unicode support
- c-style
- can’t change hash function in maps
- can’t declare/validate implements interface
- can’t import packages relatively
- case defined exports is bad
- channel API is inconsistent
- channels are slow
- compilation rules are too confining
- concurrency and parallelism are mixed
- confusing and undebuggable
- confusing/stupid syntax
- cumbersome interface
- defer is abused
- designed for stupid people
- different build approaches
- difficult to generate code automatically
- error handling
- garbage collector is nothing new; concurrent mark/sweep from the '70s
- garbage collector optimized for pause times at the cost of other desirable gc features
- garbage collector requires implicit (hidden) tradeoffs
- go generate is a quirk
- goroutine is not original and revolutionary
- hard to extend
- hard to test, hard to mock
- has pointers
- hidden types
- hostile to developer ergonomics
- immature GC
- immature toolchain
- import-based vendoring is terrible
- inconvenient
range
- is compiled
- lack of basic data structures
- misleading marketing around garbage collector
- multiple return parameters are overrated
- multiple return values have no type checking
- nil as a failure marker
- nil interfaces are not entirely nil
- no OOP
- no
map/reduce/filter
- no
this
- no algebraic data types
- no asserts
- no constructors
- no decent IDE
- no exceptions
- no first-class support of interfaces
- no first-class tuple
- no function overloading
- no function/operator overloading
- no generics
- no immutables
- no language interoperability (only C)
- no macros or templates
- no non-nullable types
- no pattern matching
- no semicolons at line endings
- no subpackages
- no sugar for slices
- no sum types
- no tagged unions
- no ternary operator
- no unused imports
- no user-type iteration
- no versioning model
- no virtual functions
- not stable
- not-so-obvious slices behaviour
- package mechanism is broken
- pointers are a mess
- polymorphism is broken
- poor design
- poor std math lib
- project layout is bad
- psuedointellectual arrogance of Rob Pike and everything he stands for
- questionable compiler rigidity
- slow json parsing
- sort.Interface approach is clumsy
- stuck in 70’s
- stuck in Unix thinking
- summary: not elegant as Python, not strong as Java
- the worst compiler toolchain ever
- too opinionated
- too simple / lack of syntactic sugar
- too verbose
- too young
- type inference is too simple
- un-googlable name
- unexpected variable shadowing
- unwieldy to code new collections
- upper-case/lower-case scoping is bad
- weird mascot (gopher)
Get involved
Feel free to add a PR with a new or old article you found on the internet. The structure is simple, just look at existing entries. Run make and check in the resulting README.md along with your updated entries.json.
{
"URL": "https://kaushalsubedi.com/blog/2015/11/10/golang-sucks-heres-why/",
"Author": "Kaushal Subedi",
"Year": 2015,
"Complaints":[
"no generics",
"slow json parsing",
"bad dependency management",
"no subpackages"
]
}
TODO
- merge complaints with the same ideas under the same names (make the complaints list smaller)
- sort reverse index by the number of articles which have that complain (popular complains to the top)
评论