His Go is a little disingenuous. This (https://gist.github.com/EricLagerg/105431503d32f18d239b) is almost as short as his D code, and functions the same.
replies(3):
Would you say that Go is not excessively verbose in non-trivial use cases ? I recently had to sort a struct list in a program. Added lines of code for sorting a single list once : 30. What the ...
You can use the standard library sort methods by making your type implement the sort interface. Heres an example taken from the example in the sort docs: https://play.golang.org/p/oeRIhHi1Ei
The only place go is more verbose is sorting, and lack of map, filter, and list comprehension. Most of the latter just means you need a 3 line loop where you have one line in python. But that should not be a great effect on any reasonable size program.
fileBytes, _ := ioutil.ReadAll(<file>)
text := string(bytes.Join(bytes.Split(fileBytes, '\n')))
fmt.Println(text)
Sorting requires implementing three methods, at least one of which is usually given to you for free (Len). A simple case will usually cost about 9 lines of neatly formatted code, 3 if you're not so neat (which the Go sort library does itself).
func (sl structSlice) Len() int { return len(sl) }
func (sl structSlice) Less(i, j int) bool { return sl[i].MyKey < sl[j].MyKey }
func (sl structSlice) Swap(i, j int) { return sl[i], sl[j] = sl[j], sl[i] }
Yes, I know the Go authors do it too. And of course we know the answer : they're ashamed of just how bad it is, and mask it by making exceptions in the style guide for this specific case. You also left out the type declaration and the actual sorting call. Here's the full code :
type myStructSlice []struct
func (ms myStructSlice) Len() int {
return len(ms)
}
func (sl myStructSlice) Less(i, j int) bool {
return sl[i].MyKey < sl[j].MyKey
}
func (sl myStructSlice) Swap(i, j int) {
return sl[i], sl[j] = sl[j], sl[i]
}
...
sort.Sort(myStructSlice(sl))
Compare to the same code in Java:
Collections.sort(theList, (SomeType s1, SomeType p2) -> p1.field.compareTo(p2.field));
sort!("a.field < b.field")(theList)
thelist.sort([](const someType& a, const someType& b) { return a.field < b.field; });
Having to tell the standard library how to swap data in a slice and to obtain a slices length is simple... why doesn't the standard library know how to work with basic types? This way I don't end up writing by accident:
func (a ByAge) Swap(i, j int) { a[i], a[j] = a[j], a[j] }>Over the course of the past few months I’ve been using Go to implement a proof of concept program in my spare time.
It's almost as if, like most people who post on Hacker News, you took a cursory look at the title, wrote some inane comment that supported your point, and squeezed out a reply.
an example from https://www.spacemonkey.com/blog/posts/go-space-monkey -
we decided to transliterate our 90k lines of Python directly to Go, line by line
The 90K number includes our tests, but without tests, the Python codebase is 36,784 lines of code. Those same lines of code became 41,717 lines of Go code. So, not that much of an increase. When you consider that's just 4,933 more lines, it's not crazy to assume most of those are closing braces.
I'd say closing braces and trivial expansions of list comprehensions into 3-5 line loops.
There's a real life example of direct transliteration, not just a rewrite. That's 13.4% more lines. I think that's pretty close.