howeman

Is there technical information on this somewhere? How is this different from AWS and from a traditional supercomputer? If I write a shared-memory parallel computation could I just run it on their platform (assuming I've done the work to make sure it can scale), or do I need to use MPI/a special language to make it all work?

In the "Checkers is solved" paper, they state "The complete 10-piece databases contain 39 trillion positions (Table 1). They are compressed into 237 gigabytes, an average of 154 positions per byte!"

Do you have any idea how this would be done? It seems crazy.

You said above you 'may start rolling your own packages'. If you're interested in helping develop the numeric ecosystem, please come join us at gonum https://groups.google.com/forum/#!forum/gonum-dev github.com/gonum.

Dan (the lead developer of biogo) is very competent and I'm sure would love bug reports and PRs in biogo as well.

> Unfortunately, there is no equivalent to Numpy/Scipy in Go.

We're trying! https://groups.google.com/forum/#!forum/gonum-dev github.com/gonum . Bug reports and contributions encouraged.

Sure, Wikipedia defines it as 3+3+3+3+3, but the Oxford English dictionary defines it the other way (as 5+5+5). They are both correct.

gonum also has LAPACK bindings

godoc.org/github.com/gonum/lapack/cgo

Assuming you need float64, BLAS and LAPACK are most easily accessed through the wrapper packages godoc.org/github.com/gonum/blas/blas64 and godoc.org/github.com/gonum/lapack/lapack64. This way code can be written to either use the native go implementations or the assembly/c/fortran ones.

I think Go is a great language for sophisticated scientific computing. Go scales well to complex code bases, and thus it is a great language for building an ecosystem. The tools are not all there yet, but the foundations are being built github.com/gonum

They are separate repos because they have different mentalities. Stat is basic statistics for a (weighted) set of values. Floats is closer to dealing with properties of a vector (norm, distance, etc.). Sample has sophisticated sampling from distributions (metropolis hastings, etc.). gonum/stat/dist has sampling distributions themselves.

Documentation can be found in godoc, i.e. godoc.org/github.com/gonum/stat, godoc.org/github.com/gonum/matrix/mat64, etc.

I mentioned elsewhere in the thread, but if you're interested in help buliding statistical tools for go, Gonum is always looking for more hands. Look at what we have in github.com/gonum, and/or come introduce yourself at gonum-dev

If you're interested in developing more stats stuff, we'd love to have you as part of the effort. gonum/stat/dist in particular needs a lot more functionality.

Gonum has many of these capabilities, but with a slightly different mentality (gonum has weights and sticks to pure []float64 while this defines types and methods, i.e. Coordinate, Float64Data)

gonum/floats for max, min, round, sum, etc.

gonum/stat for mean, std, variance, etc.

gonum/stat/sample for sampling without replacement

I don't understand this. How is enabling Go to run on android skewing the ecosystem? You'd rather them not allow it?

The Go team had nothing to do with the organization of the conference. The gophercon organizers decided who got the keynotes.

From an external viewpoint, Google the corporation has two influences. Firstly, it employs the language leaders (i.e. Russ). Secondly, Google frequently hires/gives to the Go team experts in some particular field in order to improve the implementation. For example transforming GC for the 1.5 release or moving to SSA for 1.6. As a result, Google probably has a big influence on what the important tasks are to work on. That said, it is still open source, and so outside contributors can still work on what they consider important. For example, the shared library development was all external.

To be fair, this does increase runtime size and decrease performance, but that's a necessary cost that comes with the debugging capability

I don't remember 2006 specifically, but I was on facebook in 2004. Back then, it was only open to .edu addresses. They had a list of all of the dorms at the school and the rooms in them. You would select using a pull down menu which was your room. They also had drop-down menus for all of the classes that the school offered, and there was a 'group' that was created for each class that you could use to construct study groups (or whatever). There was no news feed. Instead of the 'wall' as it is now, it was instead an editable text box that acted like the white board that is common outside dorm rooms.

The Go tool does do installation and upgrading. There's not really any configuring, and it'd be hard to do removal in any reasonable manner given how GOPATH works. What the Go tool does not do is isolate you from breaking changes upstream. For that you need someone you trust (which could be the package author or a copy of the code in gopkg.in), or be willing to fix breaking changes (which I do quite often).

How so? First was 1.0, then 1.1, then 1.2, etc.

What does OpenMP do for you that Go's built-in concurrency doesn't?

Just don't run your pendulum simulation for too long if you're using the Euler method!

Thank you for being an excellent example

Where does it fail to free memory? As of 1.4 the GC is fully precise. Concurrent GC is in the works, and is scheduled to be in 1.5 (August of this year).

But you also get a stack trace without needing an IDE and debugger.

And if you want to use external code, you can download it with and integrate it into your main package in about 90 seconds (go get + go install). In order to learn to use it, godoc is there.

You understand that the satisfaction is verified at compile time, right?

> You're not returning a sum type so it's down to convention to remember that the "real" return value is effectively garbage when the error return value is non-nil.

There are many cases where this is not true.

See the "NextDirection" method for the update.

Gonum has an LBFGS implementation https://github.com/gonum/optimize/blob/master/lbfgs.go

People write that chess has ~ 10^42 board positions. If you read the paper about solving checkers (which you should because it's excellent), they evaluated about sqrt(N) positions, and the final solution took cuberoot(N) board positions. IF that extrapolates to chess, it means that the weak solution would take 10^21 evaluations and 10^14 storage. That's big, but in the realm of feasibility.

I'd be interested in seeing things you think are done correctly as well. We're working to build a statistics package in go as well (github.com/gonum/stat). It's good that people are taking a fresh look. Our capabilities are clearly limited at the moment, and the features of Go are quite different from those of Julia, but there's still a lot that can be learned in common.

Go does have a goto statement, and one of its good uses is to transfer to an error handling block (from what I've seen).

There are also type annotations (tags), though I don't know how/if they relate to sql