Re:Golang Is Good, Structure Is Bad
by dullgiulio on Sunday October 01, 2017 @10:29AM
(#15377993)
Not really, not in this case.
The author of the article should take some time to learn idiomatic Go. "[...] I can use packages as metaphore for classes" is a big red-flag that one doesn't have the fundamentals.
When one writes Go, writes in Go. Not in Ruby, not in Lisp, not in Haskell. In Go.
Re:Golang Is Good, Structure Is Bad
by nerdponx on Sunday October 01, 2017 @09:45AM
(#15377761)
FWIW this is a problem for Python as well:
import requests
# uh-oh!
requests = []
for url in ['http://google.com', 'http://duckduckgo.com']:
with requests.get(url) as req:
requests.append(req)
You'll get
AttributeError: 'list' object has no attribute 'get'
because your sensibly-named `requests` object is shadowing the module. Obviously you could re-name it to `reqs` or something, but having module objects in a top-level global namespace can sometimes non-trivially increase cognitive load.
By comparison, R and Common Lisp have special syntax for accessing objects in namespaces. There are good and bad approaches to both. Having namespaces/packages exist alongside other objects makes it easier to reflect on their contents, obviating the need for specialized access functions.
Re:Golang Is Good, Structure Is Bad
by lowmagnet on Sunday October 01, 2017 @10:44AM
(#15378087)
`go vet -shadowstrict` works pretty well for the shadowing problem.
Look at go's `net/url` package. The type is `URL` because it's exported, there's no `New` function. It instead uses the conversational `Parse`.
`url.URL` does stutter, and `url.Parse` probably belongs in the url module, with the type in `net` to reduce stutter.
This would make `net/URL` a clearer non-stuttering type. It would also make 'net/url' a library of functions with which `net/URL`s are manipulated and a clean-room fashion.
Can't help but quote: "Design patterns are bug reports filed against the language" (Peter Norvig, iirc).
The author of the article should take some time to learn idiomatic Go. "[...] I can use packages as metaphore for classes" is a big red-flag that one doesn't have the fundamentals.
When one writes Go, writes in Go. Not in Ruby, not in Lisp, not in Haskell. In Go.
By comparison, R and Common Lisp have special syntax for accessing objects in namespaces. There are good and bad approaches to both. Having namespaces/packages exist alongside other objects makes it easier to reflect on their contents, obviating the need for specialized access functions.
Look at go's `net/url` package. The type is `URL` because it's exported, there's no `New` function. It instead uses the conversational `Parse`.
`url.URL` does stutter, and `url.Parse` probably belongs in the url module, with the type in `net` to reduce stutter.
This would make `net/URL` a clearer non-stuttering type. It would also make 'net/url' a library of functions with which `net/URL`s are manipulated and a clean-room fashion.
import ( . "fmt" . "log" )
func main() { Println("broken!") }