Gustavo Niemeyer

golang.org offers two types of downloads for Linux: a source tarball and a pre-compiled tarball. If you download the pre-compiled tarball, you just have to extract it somewhere and set some environment variables (all explained in detail on golang.org). If you really want to install Go via your package manager, you can install the golang package from the Ubuntu repositories. However, this package is naturally on an outdated version of Go. Also worth mentioning is godeb[1] which can generate and install a .deb of any version of Go for you. [1]: http://blog.labix.org/2013/06/15/in-flight-deb-packages-of-go

http://labix.org/gopkg.in is a rather good solution for distributing libraries with transitive dependencies. It requires critical mass for it to really take off, but the level of effort is extremely low for implementation (make a branch on github, don't break it... done!). I think this low level of effort is really important, as I have been able to simply poke authors of my favorite packages for support, and had it in a day or so. As for an internal project (non-distributed) I think vendoring is the solution everyone who is sane has always been using, why would you risk you project on a random guy deciding he wants to delete his github account.

The PPA is no longer maintained, instead the recommend solution is to use godeb: http://blog.labix.org/2013/06/15/in-flight-deb-packages-of-go

There's also the mgo library for MongoDB which is probably one of the best Mongo libraries out there (even 10gen thinks so): http://labix.org/mgo And http://github.com/lib/pq for Postgres.

It seems as though you're talking about core libraries or built in functionality of a language. But for what it's worth, if you're using Python there is this: http://labix.org/python-dateutil

We did prototype for a while with fluentd as well as Cassandra and a few other technologies which we decided not to use in the end. The answer to why we chose a lot of what we did was to satisfy our requirements. The "Minimal Hardware with Redundancy And Scale" and "Minimal Software Layers" requirements came into play in regards to your question. We found that most off the shelf technologies are great at scaling, but they have a cost that would have required us to employ a lot of hardware. We were able to reach the speed we needed by writing our own Go client to ship off the logs to our cluster, and that also gave us the customizability and control to be able to make sure we weren't consuming all of the resources our servers needed during peak times to deliver content. As for why we chose the database we did, while TokuMX is basically a drop in replacement for MongoDB, it has features that make it much more usable for our situation. Specifically, a compression rate of over 80% without negatively impacting our insert speed and document level locking. And because TokuMX works as a drop in replacement for MongoDB, we were able to use the MongoDB driver (mgo http://labix.org/v2/mgo) for Go which is just a really great tool. Additionally, we are now able to leverage the MongoDB aggregation framework which allows us to use the data in a way that builds very helpful aggregations of the data very quickly.

I've been working to get Haskell approved at my place of employment for 1.5 years but getting the US Gov't to change is rather hard; I've had to sit the "tech" people down and explain that javascript != java... with that baseline, explaining 'Why Haskell' is non-trivial. Come September, after 1.5 years of effort, I should have 'all the FOSS'. Until then I have to wait. It's worth noting that iPython Notebook + pandas vs. cassava + conduits (even with iHaskell Notebook) serve very different ends. If I need to explore how to do something, I'd use Haskell. But I'm still in phase 2 (phase 1: collect underpants) and I've yet to find anything as powerful and flexible as the iPython Notebook + pandas + hdf5 stack that also just works. I can just move faster with that stack than anything else I've ever seen. That being said, I'm knowingly deferring bugs to the runtime -- 'tis the cost of python. If you're unfamiliar with pandas, the "quick vignette" here[0] is decent enough. The reason pandas is awesome, IMO, isn't actually because pandas is awesome (which it is) but because it's embedded in a full language. Julia, R, etc... can do the same stuff (maybe faster), but I wouldn't also want to program, say, a production web-app in them (though I have high hopes for Julia). Fuzzy parsing on dates: pandas by default uses dateutil[1] which is both awesome and slow. 10GB CSV... : yeah... it's "fast for python" but pandas is admittedly doing a lot in that time, namely putting it into a…

This might help with some of the issues with go statement mentioned in the article: https://blog.labix.org/2011/10/09/death-of-goroutines-under-control https://github.com/go-tomb/tomb/tree/v2

Its not the same. Anything in the nursery can cause cancellation of all async work. Cancellation is safe to unwind in all workers by scope exit rules. Completion is just a type of cancellation. Spawn 10 workers to lookup Dog in 10 different dictionaries, the first one to get the answer wins. This is hard to do with out language/runtime cancellation support. Note below is a practical lib to get close to this https://blog.labix.org/2011/10/09/death-of-goroutines-under-control .. https://github.com/go-tomb/tomb/tree/v2

> True, but that's what people using Go have been doing for years without complaining much, so I guess it works fine for most workload. I hate to break it to you but dependency management has been a massive issue in golang until the devs formally adopted go mod. Only Google seemed okay with checking in their dependencies to version control. Everyone else was doing crazy hacks like https://labix.org/gopkg.in

http://labix.org/gopkg.in is useful, but maybe it doesn't go far enough. Perhaps it should be expanded to do the aliasing? Having the version in the package name is useful, as an incompatible API change usually requires visiting the code and this forces the issue.

Indeed, or any other case where the application is granted permission to do something sensitive (camera?) and abuses that trust. Even in those cases, though, it is an improvement to know the access exists, and to have control over it. Some more details about snap interfaces: http://blog.labix.org/2016/04/22/snappy-interfaces

The tools essentially causes that to happen (its a bad thing). When someone installs your package (and you don't pin them somehow with something like godeps, path management, http://labix.org/gopkg.in, etc) you recursively retrieve the deps from some source at HEAD and that package is now updated for every other package using that GOPATH.

I find it hard to appreciate these inventive types of API design. Something more traditional and boring, like Celery's crontab[1] or dateutils rrule[2] seem quite sufficient. For example: crontab(hour=18, minute=30, day_of_week='*') [1]: http://celery.readthedocs.org/en/latest/userguide/periodic-tasks.html#… [2]: https://labix.org/python-dateutil#head-470fa22b2db72000d7abe698a5783a4…

> Why are you not able to easily version git dependencies? Go's solution to this problem is to tell you to create an entirely new git repository for each major version. Really? If they didn't want to go full blown dependency versioning with something like CocoaPods, they could at least let you specify a git branch or tag. Take a look at gopkg.in[1]. This is a service that makes branches in other repositories go-gettable. Eg. go getting gopkg.in/foo/bar/v5 will download branch v5 from github.com/foo/bar. This seems to me to be a way of dealing reasonaly well with the issue -- the go get tool itself doesn't need to understand anything at all here. [1] http://labix.org/gopkg.in

Thank you for the comment. I was wondering if something along the lines of http://blog.labix.org/2012/08/22/multi-doc-transactions-for-mongodb would be feasible.

IIRC, Canonical joined the go community around 2010/2011 when docker has not been created. They are actually one of the early adopters of Go. Some major projects from Canonical using Go are juju[0], mgo[1], etc. 0. https://juju.ubuntu.com/ 1. https://labix.org/mgo Edit: format.

This is a cool project, though the name might be a bit confusing in conversation. The MongoDB driver for Go is called "mgo" and pronounced "mango"[0]. [0] https://labix.org/mgo

I like what the go authors think about dependencies being backwards compatible, but not everyone thinks that way, and let's face it, people make mistakes and make incompatible changes unintentionally. I started a project last weekend (still a WIP), go get version[1], that basically proxies the `go get` commands, but fools it into thinking the master branch is either a tag or a version to get around some of these problems, while aiming to still work with the go tool. For example, if you have a tag named v1.0.3, you would change your import path to be something like this: gogetver.com/github.com/user/project.v1.0.3 There's also gopkg.in[2] which does something similar, although it appears to only work with github. [1]: https://github.com/rsenk330/gogetver [2]: http://labix.org/gopkg.in

Y'all may wanna check out python dateutil. https://labix.org/python-dateutil

The code for Twik has a simple AST in it. Of course, it's Lisp, so it's perhaps too simple. http://blog.labix.org/2013/07/16/twik-a-tiny-language-for-go

I think the bit on managing dependencies could be improved with a bit more information about what other people have done. For example, SoundCloud maintains one monolithic $GOPATH in a single git repository that they can then selectively update. My personal preference to any flavor of the month Go dependency managers is gopkg.in[0], because it doesn't fool with the official tool chain (i.e. "go get", "go build"), but still allows for the versioning of packages. [0] http://labix.org/gopkg.in

links to the contest, thanks Nate Finch: http://blog.labix.org/2014/03/13/go-qml-contest http://blog.labix.org/2014/04/25/qml-contest-results

Have you looked at http://labix.org/gopkg.in It is an attempt to make things still go gettable and maintain versioning so that API breaking changes don't ruin your go get. I think it's a good start.

Other similar projects: Otto (JavaScript interpreter): https://github.com/robertkrimen/otto Twik (Scheme like): http://blog.labix.org/2013/07/16/twik-a-tiny-language-for-go

For Play: http://robfig.github.io/revel/ For Mongo: Most people use mgo http://labix.org/mgo For precog: dont know, but there might be something, but probably not.

Not really. We utilize python-dateutil to help recognize the different date formats, but everything else we built ourselves. http://labix.org/python-dateutil

If you want the latest Go version on Ubuntu : http://blog.labix.org/2013/06/15/in-flight-deb-packages-of-go

Actually I think I may have first picked it up from this vclock library: http://labix.org/vclock

I just put a small go learning project up on github. https://github.com/danenania/go-promocodes It's a tiny rest api for generating promo codes to bypass in app purchase locks in an ios app. It uses gorilla/mux[1] for routing, mongodb with mgo[2], and is heroku-ready[3]. One file and 129 lines all told. Perhaps it can help. 1: http://www.gorillatoolkit.org/pkg/mux 2: http://labix.org/mgo 3: http://mmcgrana.github.io/2012/09/getting-started-with-go-on-heroku.ht…