Hacker News Reader

There is - Go is a terribly fun language in the domains that it's good at. Like some other fun languages, if you take the time to get into 'the go way' of doing things, you'll get a new perspective on some kinds of programming that'll help you in general.

Go is drastically less bloated than Java. Stupidly fast compilation and running lets you use it almost (but not quite) like you might Python for some things.

A recent example for me: Writing a quick & dirty server that talked to a device that was spouting a stupid binary serial-over-TCP protocol. Goroutines made handling the bidirectional communication trivial, and go being a bit on the low-level side makes it easy to cope with binary protocols without worrying that your chars and bytes and unicode characters are getting all mixed up. You can do all this in Java - but it's so clean in Go.

My current playbook looks something like:

Network servers: Go. Go go go and more go. Things that talk to lots of other things and involve interesting communication are a natural match. I rewrote my pi searcher in Go a year or so ago, for example - http://da-data.blogspot.com/2013/05/improving-pi-searchers-s... - and this year was able to run the thing through Pi day on only a single (larger) AWS instance. Woot. We use it for research, such as writing Paxos derivates. Great stuff.

Go's also pretty amazing for little utilities if you want them to be faster than Python -- particularly if you want the launch time to be faster than Python. Which can be great for utilities you build to use in loops in shell scripts, etc. The fact that they're purely statically linked makes a lot of otherwise hairy cross-platform nastiness just go away.

The fact that it's statically typed and includes great, easy-to-use parsing support for itself also makes it much better for refactoring than Python is. The tools aren't as mature as those for Java, but the language is well-designed to support it (think "go fix" -- which can automatically port forward much old code to newer versions of the language). The tooling for this kind of thing is great for Java, good for C and Go, and absolutely horrible for Python. As a consequence, Go can more roubustly handle being worked on in very large codebases and teams. What would be a slightly scary regexp replace in Python can be a much more syntactically and semantically safe change in Go (at the cost of a little more writing of the replacement code).

Tensorflow (and most things numeric): Python. Because it was pre-decided. :) But, more seriously, Go's lack of generics hurt it here (you can't express matrix/tensor manipulation natively, and saying A * x is about as right as it gets when you're talking math). The ML community has adopted Python to a pretty strong degree, particularly because of NumPy, and so it fits in really well there. I still get grumpy about it -- I've lost count of the number of times I've messed things up that static checking could have caught, requiring quite a long time for tests/running it to finally do so. But I do like Python, to the point of:

Beginners: Python. I pushed hard to switch CMU's intro course for non-majors to it, and succeeded with a lot of help from others. It's awesome seeing what a bunch of motivated, smart first-years can accomplish in Python in one semester. Damn. And they can 'take it with them' -- scientists/engineers and numpy are a pretty good match, for example.

Fast as hell: C++, light on the ++, heavy on the C. A lot of our research code is very low-level. I'm still finding Rust incredibly annoying, but I may just be a slow learner, and it's on my list to take a really serious look at it after I'm back from Google.

(You'll note that nothing that I do involves a UI. I'm a unix & systems person through and through, which helps explain the utter lack of Java, C#, Swift, etc. in my life.)

View on HN

import Foundation let N = 1000000 func generateTestData() -> [String] { var a = [String]() for _ in 0..<N { a.append(",,abc, 123 ,x, , more more more,\u{A0}and yet more, ") } return a } func splitAndTrim(s: String, sep: UInt16) -> [String] { var result = [String]() result.reserveCapacity(10) let space = NSCharacterSet.whitespaceAndNewlineCharacterSet() let cs = s.utf16 let eos = cs.endIndex var begin = eos var end = eos for i in cs.startIndex..<eos { let c = cs[i] if c == sep { result.append(begin == eos ? "" : String(cs[begin..<end.successor()])) begin = eos end = eos } else if !space.characterIsMember(c) { if begin == eos { begin = i } end = i } } result.append(begin == eos ? "" : String(cs[begin..<end.successor()])) return result } func doSplits(data: [String]) -> Int { var count = 0 let sep = ",".utf16.first! for s in data { let parts = splitAndTrim(s, sep: sep) count += parts.count } return count } let data = generateTestData() let start = NSDate() let sum = doSplits(data) print("elapsed: \(NSDate().timeIntervalSinceDate(start))") print("sum: \(sum)")

import java.util.List; import java.util.ArrayList; public class ParseTest { static int N = 1000000; public static void main(String[] args) { List<String> data = generateTestData(); for (int i = 0; i < 3; ++i) { long start = System.currentTimeMillis(); int sum = doSplits(data); System.out.println("elapsed: " + ((System.currentTimeMillis() - start) / 1000.0 + " seconds")); System.out.println("sum: " + sum); } } static int doSplits(List<String> a) { int count = 0; for (String s : a) { List<String> parts = splitAndTrim(s, ','); count += parts.size(); } return count; } static List<String> splitAndTrim(String s, char sep) { List<String> result = new ArrayList<>(10); int eos = s.length(); int begin = eos; int end = eos; for (int i = 0; i != eos; ++i) { char c = s.charAt(i); if (c == sep) { result.add(begin == eos ? "" : s.substring(begin, end + 1)); begin = eos; end = eos; } else if (!Character.isSpaceChar(c)) { if (begin == eos) { begin = i; } end = i; } } result.add(begin == eos ? "" : s.substring(begin, end + 1)); return result; } static List<String> generateTestData() { List<String> a = new ArrayList<>(); for (int i = 0; i < N; i++) { a.add(",,abc, 123 ,x, , more more more,\u00A0and yet more, "); } return a; } }