<p>I've seen threads like this a few times on <a href="/r/python">/r/python</a> and they're always good to get newcomers interested in the language and libraries etc.</p>
<p>So, what cool program have you created using Golang?</p>
<p>How did the experience of creating it using Go compare to another language you are skilled with?</p>
<p>What was your reason for using Go for this program? </p>
<hr/>**评论：**<br/><br/>mofirouz: <pre><p>I'm one of the engineers behind Nakama:
<a href="https://heroiclabs.com">https://heroiclabs.com</a>
<a href="https://github.com/heroiclabs/nakama">https://github.com/heroiclabs/nakama</a></p>
<p>It's a fast, real-time, extendable server aimed for apps and games. It has user accounts incl social login, a complete friends graph, groups and clans, notifications, cloud storage.</p>
<p>Some game specific features are real-time multiplayer, filter based matchmaking and leaderboards and leagues.</p>
<p>It comes embedded with a Lua runtime environment so you can extend or override the default server behaviours.</p>
<p>Been working on it for the past 2.5yrs. We've made sure to make Nakama horizontally scalable using in-memory data structures and Dotted Version Vectors.</p>
<p>Let me know what you think. </p></pre>Thaxll: <pre><p>Building the leaderboard around SQL is interesting, not sure how fast it is, I'm sure you looked at Redis as well?</p></pre>nwsm: <pre><p>how fast does a leaderboard need to be</p></pre>Thaxll: <pre><p>If you have millions of players it needs to be fast. I got down voted probably by people that never work on that kind of problem.</p>
<p>Sorted set
<a href="https://redis.io/topics/data-types" rel="nofollow">https://redis.io/topics/data-types</a></p></pre>doot: <pre><p>Just cache it, who cares</p></pre>Thaxll: <pre><p>Yeah cache things that keep moving...</p></pre>Kraigius: <pre><p>Wouldn't that cause a problem by using redis since the dataset (probably just usernames sorted by score) needs to be kept in memory at all time and most of it will never be accessed anyways?</p>
<p>I haven't had to solve this problem myself but I would tend to agree with you that redis is fast and simple enough for a leaderboard. </p></pre>mofirouz: <pre><p>Leaderboards are an interesting problem space, and depending on the features of the leaderboard, you can extend the complexity even more. For instance, do you want the leaderboard to only show the top 100, or a hay-stack query to show where the current player is in the leaderboard.</p>
<p>If it's the former, caching the data could be generally ok because once the leaderboard settles the top X players rarely change. Hay-stack queries are more interesting, on one hand the player wants to know exactly where they are, but no point giving an exact rank information because the leaderboard could be moving up and down at snapshot, so as long as the rank is somewhat in the expected region it should satisfy the problem.</p>
<p>Solving both types of leaderboard queries in redis is challenging because of three reasons;
A) Depending on your key design, you likely will end up duplicating the information across two tables, one sorted by rank, the other sorted by username and other bits of meta information.
B) Scaling redis means sharding it, which brings a whole lot of headache and data re-partitioning which is just a whole lots of devops problems.
C) Usually leaderboard entries have some meta information associated with them. For instance, if you are storing race track times, you might need to store the track/weather conditions with it (see Top Gear), or more common example (from experience dealing with thousands of games), facebook profile URLs.</p>
<p>Last point, especially about Nakama:</p>
<p>We made the conscious decision of going with Go because we wanted to ship one single binary, and in the same manner wanted to only depend on one database, rather than a plentha of different databases/queues/glue software that are optimized for one single purpose. We internalised a lot of different things within Nakama. For example, Nakama doesn't depend on etcd or zookeeper for service discovery, it's built into Nakama. The goal is to get the server running as easy as possible and keep it running with minimum infrastructure needs.</p>
<p>We optimised (the hell out of) the queries that we ran against CockroachDB / Postgres to make sure that the API commands directly hit indexes and are as performant as possible. We've documented as much of the queries like this one:</p>
<p><a href="https://github.com/heroiclabs/nakama/pull/43" rel="nofollow">https://github.com/heroiclabs/nakama/pull/43</a></p>
<p>We've <code>EXPLAIN</code>ed every query to make sure all is checked, and how they perform across clusters of Cockroach nodes.</p>
<p>Hope this sheds some light :)</p></pre>sgmansfield: <pre><p>My team wrote a memcached proxy/server for use at Netflix to enable a disk-backed memcached-like server: <a href="https://github.com/Netflix/rend/">https://github.com/Netflix/rend/</a></p>
<p>Currently helping us save a boatload of money by enabling more efficient storage of large (tens of terabytes) data sets in cache. Go was fantastic for this purpose because <em>there is no magic</em> and I could dig in as deep as I needed to in order to make it fast. Case in point: the histogram code in the metrics package even has some assembly to help with bucketing values: <a href="https://github.com/Netflix/rend/blob/master/metrics/lzcnt_amd64.s">https://github.com/Netflix/rend/blob/master/metrics/lzcnt_amd64.s</a></p>
<p>We're using RocksDB to do disk storage, so the CGo performance, even though people rip on it, has been good to us.</p>
<p>Currently it's doing over 5 million operations per second at peak with Go only adding something like a few dozen microseconds of latency, so it looks like Go was the right choice for us.</p></pre>natefinch: <pre><p><a href="https://magefile.org">https://magefile.org</a> (makefile replacement using go code)</p>
<p><a href="https://gnorm.org">https://gnorm.org</a> (DB schema->code generator)</p>
<p><a href="https://github.com/natefinch/gocog">https://github.com/natefinch/gocog</a> (code generator)</p>
<p><a href="https://github.com/natefinch/gorram">https://github.com/natefinch/gorram</a> (go run for any go function)</p>
<p>The fact that go compiles to a standalone executable is a big benefit for tools you want to distribute to people who might not be go devs. For me, that's a factor for Gnorm and Gocog, which both are specifically aimed to be used by devs of any language.</p>
<p>I've written similar things in C#... which of course would require a .net installation. I think Go's stream handling (reading from / writing to files etc) makes the go code quite nice. </p>
<p>Gorram and Mage both generate code that gets run by the go tooling, they're very Go-specific, but the fact that I can compile fast enough to generate and compile code without the user feeling like things are running too slowly is a huge win. of course, in an interpreted language, there's no compilation step, so it wouldn't apply. </p>
<p>Go's strong standard library means that I don't have to reach for third party libraries that often, which makes my code easier to build and more reliable.</p>
<p>Go's error handling means that I always know what calls can fail, and so I think about what I should do if something fails every time.... this makes my programs more reliable.</p></pre>mmatczuk: <pre><p>Hi I'm the author of <a href="https://github.com/mmatczuk/go-http-tunnel" rel="nofollow">https://github.com/mmatczuk/go-http-tunnel</a> Secure tunnels to localhost - open source ngrok alternative build on top of HTTP/2</p>
<p>Very useful for hackathons, demos or developing web hooks.</p></pre>gbrayut: <pre><p>Very nice! Been looking for something like this. Thanks!</p></pre>mmatczuk: <pre><blockquote>
<p>seful for hackathons, dem</p>
</blockquote>
<p>Thanks! It kind of took off and now it's the fastest growing project according to golanglibs <a href="https://twitter.com/michalmatczuk/status/919218596890497024" rel="nofollow">https://twitter.com/michalmatczuk/status/919218596890497024</a></p></pre>jfarlow: <pre><p>At Serotiny we've built a 'biologically aware API' in Go that powers the design, construction, evaluation, and prediction of <a href="https://serotiny.bio/notes/proteins/">novel multi-domain proteins</a> (and powers that dynamic webpage, via <a href="https://gohugo.io/">Hugo</a>).</p>
<p>It's fast, strongly-typed, interfaces well with machine learning systems, supports immediate deployment across many different kinds of systems, and is easily readable/approachable for newcomers.</p>
<p>It powers our genetic design web-app found here: <a href="https://serotiny.bio/pinecone/">https://serotiny.bio/pinecone/</a></p></pre>powerage99: <pre><p>GRV - Git Repository Viewer: <a href="https://github.com/rgburke/grv" rel="nofollow">https://github.com/rgburke/grv</a></p>
<p>GRV is a terminal interface for viewing git repositories. Refs, commits and diffs can be browsed through. Ref’s and commits can also be filtered using a simple query language. It's not complete yet and is under active development with new features still being added.</p>
<p>I found the development much more straight forward and quicker using Go, especially compared to C which I did initially consider using. The standard library is comprehensive and well documented. There's also an extensive set of quality libraries available which have been developed over the years and are easy to use in a project. Having garbage collection helps a lot. No matter how diligent I was when using C there would always be a memory leak or double free somewhere.</p>
<p>I chose Go in the end as I was impressed with the language having spent a weekend trying it out. The good support for concurrency and language features such as channels were a big plus. I also liked the fact it integrates really well with C using cgo, as I wanted to use a couple of C libraries. Finally the performance is good and compiling down to a single binary is a nice bonus.</p></pre>goenning: <pre><p>I'm building an open source minimalist and clean alternative to UserVoice, where the community can suggest, discuss and vote on ideas/feature requests/suggestions, etc.</p>
<p><a href="https://github.com/getfider/fider">https://github.com/getfider/fider</a> is built with Go, React and TypeScript</p></pre>earthboundkid: <pre><p>Lots of fun small apps. </p>
<p><a href="https://github.com/carlmjohnson/opensesame">https://github.com/carlmjohnson/opensesame</a></p>
<p><a href="https://github.com/carlmjohnson/heffalump">https://github.com/carlmjohnson/heffalump</a></p>
<p><a href="https://github.com/carlmjohnson/json-tidy">https://github.com/carlmjohnson/json-tidy</a></p>
<p><a href="https://github.com/carlmjohnson/sudoku">https://github.com/carlmjohnson/sudoku</a></p>
<p><a href="https://github.com/carlmjohnson/shitpic">https://github.com/carlmjohnson/shitpic</a></p>
<p><a href="https://github.com/carlmjohnson/pomodoro">https://github.com/carlmjohnson/pomodoro</a></p></pre>weberc2: <pre><p>I'm using Go to build a functional language the compiles to Go. I could have used other languages, but static typing is important for compilers and most languages have over-engineered build tooling. Also, I would like for the compiler to be ported over to the language it implements; since it targets Go, this allows me to gradually port the compiler from Go into the source language.</p></pre>pobbly: <pre><p>Sounds cool - is it working? Got a link?</p></pre>weberc2: <pre><p>I don't have anything working end-to-end yet. I just built a type inference repl for toying around with the inference system. Hopefully I'll have something working end to end in a few weeks, but that largely depends on how much time I get to work on it.</p></pre>natdm: <pre><p>Sounds neat. I'd love to see that. </p></pre>efreese: <pre><p>Rat! <a href="https://github.com/ericfreese/rat" rel="nofollow">https://github.com/ericfreese/rat</a></p>
<p>EDIT: It allows you to build custom interactive terminal applications easily by composing shell commands.</p>
<p>The reader/writer interface is really nice to work with and the concurrency model made it simple to spin up many concurrent annotators. I do a lot of my professional work in ruby and JavaScript, so coming from that, the static type-checking was very refreshing.</p>
<p>I also wanted it to be a standalone executable with no dependencies, and to be super fast. So far Go has delivered on everything except for the one downside of having a larger memory footprint than if it had been written in C or a similar non-garbage-collected language because IIRC Go doesn't release all collected memory back to the OS but hangs onto it assuming it will need to use it again soon. There may be something I can tweak to take care of that though.</p></pre>__crackers__: <pre><p>You didn’t actually say what it does. </p></pre>efreese: <pre><p>Well that's what the link was for! I'll edit it</p></pre>gxti: <pre><p>A cross-platform code signing and package signing tool called relic: <a href="https://github.com/sassoftware/relic">https://github.com/sassoftware/relic</a></p>
<p>Supports signing a wide variety of file types (windows executables, RPMs, even .appx and visual studio extensions) using private keys in a HSM or plain file. Can run either standalone or in a client-server mode that is very efficient and doesn't require any scratch space on the server.</p>
<p>Go was a great choice since being able to string together pipelines of bytes is a cakewalk. For some file types it ends up spawning half a dozen different digesters consuming different streams of bytes all without buffering anything to disk. There's also a wide variety of cryptographic algorithms and crypto-related encodings (ASN.1 in particular) ready to go that support a surprising number of use cases. Doing low-level crypto stuff in Python can be like pulling teeth because libraries tend to only expose the bare minimum functionality.</p></pre>The_Jare: <pre><p>A little cross-platform textmode file manager <a href="https://github.com/TheJare/jm">https://github.com/TheJare/jm</a></p>
<p>Go is the easiest language to come back to after months of not using it. Also the cleanest cross-platform experience. It's just cozy and comfortable. </p></pre>nohoudini: <pre><p>1.) A git based code review tool incl. web interface. It's a lightweight gerrit clone and also has a command line tool to create change lists, view status etc. I wanted something similar to gerrit but which is simple enough to setup and use (for small teams). It's in production in our company for almost a year but some features are still missing like pagination, notification via email (notification via chrome desktop notification works) and some goodies like that. Maybe I will open source it one day (if there is any interest).</p>
<p>2.) Go is a lot simpler than other languages but still fast. I also like that it compiles to a single binary.
3.) Simplicity for setup & cross-compilation.</p></pre>GreatDant0n: <pre><p>1) I would love to see the screenshot of the app. Gerrit seems quite powerful although for some reason not that popular.</p>
<p>Yeah it compiles into a single binary which is really cool, but there are usually other files that are not embedded (html, css, js). I wrote bash script that copies public files and compiled binary together in one folder, but it's kind of annoying thing to copy and paste this script in every little project.</p>
<p>How do you deal with this problem?</p></pre>Altrius: <pre><p>I picked up go a few years ago because I wanted to learn a new language and fell in love with how fast I could spin up a functionally useful server that could do real work. I've used it for several web scale systems and a bunch of tooling and automation. The most interesting things were stuff like a access control service that used a mix of data sources (some flat files, some DNSBL, MySQL, and some NoSQL based systems) together behind a single API call. The part I loved about it is that we found that it could handle enough DB requests to melt the DB and still serve up responses from the DNSBL or cached flat files with almost zero impact on the normal response times we see for request that use the cached flat file or DNSBL data. Goroutines are awesome.</p></pre>marijnfs: <pre><p>I made a Mandelbrot fractal generator: <a href="https://github.com/marijnfs/gomandel" rel="nofollow">https://github.com/marijnfs/gomandel</a>
It was quite easy to make it multicore because of go functions.</p></pre>jeffail: <pre><p>I've made a messaging bridge that links lots of different protocols and messaging queues together in various configs: <a href="https://github.com/Jeffail/benthos" rel="nofollow">https://github.com/Jeffail/benthos</a></p>
<p>And also a collaborative code editor for editing local files over LAN, similar to how it works in google docs: <a href="https://github.com/Jeffail/leaps" rel="nofollow">https://github.com/Jeffail/leaps</a></p></pre>Cvballa3g0: <pre><p>Leaps sounds/looks like a cool project! I'm impressed!!</p></pre>eikenberry: <pre><p><a href="https://github.com/eikenb/udev-notify" rel="nofollow">https://github.com/eikenb/udev-notify</a></p>
<p>Nothing big, but really scratched an itch I had for a long time. It is a tool to watch for device Udev events, matching on a property and running a configured command. Designed to run as part of a user session to do things like use xinput to configure devices. </p></pre>brtzsnr: <pre><p>I <a href="https://bitbucket.org/zurichess/zurichess/overview" rel="nofollow">created</a> a chess engine: <a href="http://www.zurichess.xyz" rel="nofollow">www.zurichess.xyz</a>. It's quite strong at ~2800 Elo, ranking around 60-70 of all chess engines. Afaik, it's the strongest chess engine written in Go.</p>
<p>The main issue I had (and still have sometimes) was the performance. I did some Go compiler <a href="https://go-review.googlesource.com/q/owner:brtzsnr@gmail.com" rel="nofollow">improvements</a> for the SSA backend which was a great experience.</p>
<p>I'm comfortable with both Go and C++. For this projected I used Go because I didn't want to waste time debugging memory issues nor focus on micro optimizations. Now there are enough tools for C++ to address my initial concerns, but Go also has come a long way, too.</p></pre>mcandre: <pre><p><a href="https://github.com/mcandre/stank">https://github.com/mcandre/stank</a></p>
<p>A collection of POSIX shell script analyzers.</p>
<p>In the past, I would have written such tools in Ruby, being a tremendously productive language. Python plateaus pretty quickly into boilerplate tedium.</p>
<p>I switched to Go for efficiency. Still incredibly productive, and I do prefer statically typed languages for robustness. Being able to produce native Windows, macOS, Linux, and other platform binaries FROM any of these systems TO any of these systems is a killer language feature.</p>
<p>Oh, and Go has objects but no inheritance, just interfaces, a huge design win. OOP can go fuck itself.</p></pre>jechols: <pre><p><a href="https://github.com/uoregon-libraries/rais-image-server">https://github.com/uoregon-libraries/rais-image-server</a></p>
<p>For the UO Libraries (as I once posted on google groups), I took an existing prototype of an image server and over time ended up rewriting the majority of the code in order to create something that drastically improved our ability to serve JP2 images (which are notoriously slow to decode) quickly and efficiently.</p>
<p>We "chose" Go because the prototype was already in Go, and we couldn't see any way to do the project with a different language very easily. We had to have something that could act as a standalone server that integrated with libjpeg, and could serve up images as fast as possible.</p>
<p>It was my introduction to Go, so it was really sloppy at first, but I found the learning curve to be very small. I was writing simple C bridges (to integrate with low-level libjpeg code) pretty much from day one, and having to handle a domain that was way over my head at that time (jp2 decoding).</p>
<p>I found myself starting to dislike dynamic typing as I got deeper into Go with this project as well as others. Being able to quickly compile and see my obvious typos was a huge benefit, and made me feel a lot more productive. I really love that I can find and fix typos, type errors, etc. without crazy test suites that cost as much as the app to build and maintain. The tooling is amazing, too - various tools to try and lint PHP, Python, or Ruby have always felt to me that they're too slow and still fall short.</p>
<p>There are plenty of annoyances I've had with Go, but so far I've found it to be the "least sucky" language I deal with. It often takes more code to do things in Go than Python or Ruby - but on the flip side, there's a lot less magic to try and remember, and again, far less need to unit test things just to find typos or verify APIs are being called properly.</p></pre>RmManeschi: <pre><p>I made a stress tool for lorawan network server <a href="http://lorhammer.itk.fr" rel="nofollow">http://lorhammer.itk.fr</a> </p>
<p>It permit to stress your infra before your real sensors break your stack.</p>
<p>It's a "work in progres" project but feedback are welcome ;)</p>
<p>Futhermore, i made a tool to auto update dependencies with direct pull-request (or merge-request for gitlab) <a href="https://gitlab.com/ContinuousEvolution/continuous-evolution" rel="nofollow">https://gitlab.com/ContinuousEvolution/continuous-evolution</a></p>
<p>The idea behind this project is to open pull-request and developer can choose what to upgrade directly in GitHub (or gitlab). And to update all things in one shot (front npm, back pip/Maven, infra docker/docker-compose...)</p>
<p>The configure by pull-request will happen when <a href="https://gitlab.com/ContinuousEvolution/continuous-evolution/merge_requests/36" rel="nofollow">https://gitlab.com/ContinuousEvolution/continuous-evolution/merge_requests/36</a> will be merged ;)</p>
<p>We have not lot of tools manager today because we want to stabilize API before adding lot of implementations but help is welcome ! And we will not refuse yours ;)</p></pre>Defender90: <pre><p>I wrote Sparkyfish, an open-source network speed tester, inspired by Speedtest.net, but with a server-side piece that you can run yourself. Unlike Speedtest, the ISPs don't purposefully prioritize this traffic higher so you'll get a truer picture of your actual speeds:</p>
<p><a href="https://github.com/chrissnell/sparkyfish" rel="nofollow">https://github.com/chrissnell/sparkyfish</a></p>
<p><a href="https://imgur.com/T3IRjwZ.gif" rel="nofollow">Screenshot here</a></p></pre>bediger4000: <pre><p>I wrote a program to do Raymond Smullyan's Tableaux Method of proving that a propositional logic formula, a command line tic-tac-toe variant called "squava", self-replicating program, narcissist program, almost-narcissist program</p>
<p><a href="https://github.com/bediger4000/tableaux-in-go" rel="nofollow">https://github.com/bediger4000/tableaux-in-go</a></p>
<p><a href="https://github.com/bediger4000/squava" rel="nofollow">https://github.com/bediger4000/squava</a></p>
<p><a href="https://github.com/bediger4000/Self-replicating-go" rel="nofollow">https://github.com/bediger4000/Self-replicating-go</a></p>
<p>Also, I did the "kilo" text editor in Go, and then refactored it somewhat:</p>
<p><a href="https://github.com/bediger4000/kilo-in-go" rel="nofollow">https://github.com/bediger4000/kilo-in-go</a></p>
<p><a href="https://github.com/bediger4000/GoKilo" rel="nofollow">https://github.com/bediger4000/GoKilo</a></p></pre>opennota: <pre><p><a href="https://github.com/opennota/tl" rel="nofollow">https://github.com/opennota/tl</a></p>
<p>A web app for translators. There's a GIF screencast.</p></pre>DSQEU: <pre><p>Not program but package, which mostly runs in the background of the programs it's used in, so I consider it a program.
GoLog, a package to use during development. Lets you set logging methods in a variety of ways, many of which don't require you to change your code.
1. You can easily add your own log methods, such as dumping logs to mongoDB or sql
2. You can add your own methods to change* your active log methods on a function by function basis, while your code is running, such as changing them from a gui or a text file.
3. Runs concurrently, so benchmarks are fairly accurate and it doesn't interrupt your actual program all that much.</p>
<p>This is the first non-proprietary thing I've worked on, so if any of you feel you would benefit from having access to an efficient logger that doesn't make you constantly edit your code then pm me and I'll link it to you when first draft is done, likely this next week some time. Wanted to get some beta testers before moving forward</p></pre>mishudark: <pre><p>I'm engineer at Schibsted Media Group</p>
<p>My team created an automatic Ad moderator, reducing the fraud in 20%</p></pre>saturn_vk: <pre><p>I made a feed aggregator that I use on a daily basis. Almost finished with 2.0 as well. I initially made it to learn go, and there were paces I wish go had unions and even simple java style genericas</p>
<p><a href="https://github.com/urandom/readeef" rel="nofollow">https://github.com/urandom/readeef</a></p></pre>sacado: <pre><p>I wrote an AI module for a nao robot. The module is meant to let the robot win at word games.</p>
<p>Why go? We needed fast development to test different strategies, an efficient language to perform more simulations in the alloted time, and we needed dead easy deployment on the robot. Nothing but go came close of solving those needs.</p></pre>shazow: <pre><p><a href="https://github.com/shazow/ssh-chat" rel="nofollow">ssh-chat</a> was very fun to build and a lot of people like it. It's a custom SSH server that presents an IRC-inspired chat room instead of a shell.</p>
<p>You can give it a try by ssh'ing into chat.shazow.net:</p>
<pre><code>$ ssh chat.shazow.net
</code></pre>
<p>The reason I built it (or built it in Go): I was reading through the Go standard library (which I'm a big fan of) and I noticed the excellent <a href="https://godoc.org/golang.org/x/crypto/ssh" rel="nofollow">x/crypto/ssh</a> and I thought to myself: It wouldn't be too hard to make a chat room out of this! Few hours later, I had a basic prototype. Then things got out of hand and next thing I knew it was fleshed it out into a full chat server.</p>
<p>I feel like a lot of my projects have been inspired by seeing some excellent Go library and thinking "hey, I could build something cool out of this pretty easily!"</p></pre>pobbly: <pre><p>I made a little collaborative drawing app with go and <a href="https://github.com/olahol/melody" rel="nofollow">https://github.com/olahol/melody</a> for websockets:</p>
<p><a href="http://oursket.ch/" rel="nofollow">http://oursket.ch/</a></p>
<p>It needs more features to make it more fun. It's just a starting point.</p>
<p>Go was a pleasure to use for this. Previously I would have used Node.js, but the Go just feels lighter. I'm working on a larger app now, though, and would really like a more helpful and expressive type system.</p>
<p>I don't mind sharing the source if you're interested.</p></pre>ask: <pre><p>I made a <a href="https://github.com/abh/geodns" rel="nofollow">DNS server</a> that runs the DNS service for the <a href="https://www.ntppool.org/" rel="nofollow">NTP Pool</a>. Something like hundreds of millions of users, several billion DNS queries a day on a tiny budget. (You can look up with Google or AWS charge for 60 billion queries a month).</p>
<p>The staging version of the NTP pool is using a Go program to <a href="https://community.ntppool.org/t/beta-site-changes-monitoring-updates/659" rel="nofollow">do the monitoring</a> of the servers, too.</p>
<p>The original version of this was in Perl. I used Go because it was an easy way to get something production ready that's faster and can use multiple CPUs. At the time the system got less queries and the Perl version actually worked fine, except a few times a day when the query rate briefly spikes to several hundred thousand basically within a second.</p>
<p>I've made a bunch of other things in Go since, but the DNS server was the first thing I used Go for.</p></pre>qudat: <pre><p>I wrote a sentence tokenizer CLI and API written in golang.</p>
<ul>
<li><a href="https://github.com/neurosnap/sentences" rel="nofollow">https://github.com/neurosnap/sentences</a></li>
<li><a href="http://sentences.erock.io" rel="nofollow">http://sentences.erock.io</a></li>
</ul></pre>tural-esger: <pre><p>I have built <a href="https://engossip.com" rel="nofollow">https://engossip.com</a> and my personal website <a href="http://turalasgar.pro" rel="nofollow">http://turalasgar.pro</a> on Go. Go is my favorite language.</p></pre>gen2brain: <pre><p>I wrote server with api for capturing screenshots of websites <a href="https://github.com/gen2brain/url2img" rel="nofollow">https://github.com/gen2brain/url2img</a> , and app that can turn any webcam into an IP camera <a href="https://github.com/gen2brain/cam2ip" rel="nofollow">https://github.com/gen2brain/cam2ip</a> .
Also, I created an app to watch and stream movies from magnet links <a href="https://github.com/gen2brain/bukanir" rel="nofollow">https://github.com/gen2brain/bukanir</a> .</p></pre>brotheronweb: <pre><p><a href="http://hottopicsnews.com/" rel="nofollow">http://hottopicsnews.com/</a> - the curated list of news and topics. It's more news aggregator now but I'm working on machine learning stuff to make it more interesting.</p></pre>DeedleFake: <pre><ul>
<li><a href="https://github.com/DeedleFake/sirdsc" rel="nofollow">sirdsc</a>, a SIRDS generator. The code's really old and in severe need of some pretty heavy refactoring and reworking, but it should still work.</li>
<li><a href="https://github.com/DeedleFake/wdte" rel="nofollow">WDTE</a>, a simple, embeddable, functional-ish scripting language designed primarily for integration into existing projects. For example, want to be able to integrate some really simple scripting into a game you're working on? WDTE can be integrated with very few lines of code and doesn't have a VM, so there's no need to worry about dealing with an entire separate runtime like you do with Lua or JavaScript.</li>
<li><a href="https://github.com/DeedleFake/imgsize" rel="nofollow">imgsize</a>, a simple middleware for doing on-the-fly image resizing. I haven't looked at this one really recently, so the Heroku instance I had running it might not be working anymore.</li>
<li><a href="https://github.com/DeedleFake/ps2avglogin" rel="nofollow">PS2AvgLogin</a>, a little program for tracking the average amount of time spent logged in by players in the game <a href="https://www.planetside2.com" rel="nofollow">PlanetSide 2</a> and presenting the information with a web interface.</li>
</ul></pre>RevMen: <pre><p>I've been building trading bots for crypto-currency exchanges.</p>
<p>Easy concurrency and excellent http and websockets libraries make Go very well-suited for this.</p>
<p>It's a fun and exciting project that has, at times, been quite profitable.</p></pre>
