This post walks through how I created the Go Templates Playground. It pulls Go template rendering capabilities directly into your browser with WebAssembly (Wasm). I was motivated to this after recently seeing the utility of other similar environments out there for different programming languages1. The Go template language has relatively wide adoption in projects like Helm and Hugo, which this tool can be used to prototype and experiment for. I’ve also been interested in incorporating Wasm into a deployed project, and this was a great opportunity for it, as well as chance to play with alternate approaches to help bring what are traditionally backend languages to the browser. It is built into my personal site to simplify development and deployment.
This post covers the creation of a multi-layer neural network written in Go. We will walk through the basics of what neural networks are and how they work, specifically looking at some of the earliest types of feed-forward neural networks. We will then walk through the implementation of a Multi-Layer Perceptron (MLP). Our goal in this process is to create a network that performs well at recognizing handwritten digits on the MNIST dataset.
With the relatively recent release Go 1.5, there are a variety of interesting areas to look at in regards to what’s changed with the language. As one would expect based on both Go’s philosophy and it’s future compatibility guidelines, not much has changed from a language feature standpoint. Still, there a number of exciting under-the-hood enhancements in the latest release.
New functionality has been introduced to the packaging system in two ways. First, support for internal packages has been brought out of it’s experimental phase in Go 1.4 where it was being testing within GOROOT to now apply to packages within the GOPATH. This will allow Go packages to divide their different functions up into more logical components without exposing APIs in unwanted ways. This is a pattern that the App Engine SDK uses well, wrapping supporting functionality that is largely auto-generated in internal packages, making the logical code exposed through the API more readable and easier to maintain.
These days, I spend a lot of time working with, designing, and implementing APIs. Since Meta is a microservices based application, the contracts that those APIs provide are crucial to designing the interactions with them. Quickly, maintaining good documentation and client libraries becomes nearly as important of a part of the applications as the code itself. Each step forward in functionality must provide solid footing to keep on building.
A spectacular tool that we have been using is Apiary, a service that provides API documentation through a super set of markdown that is fully parsable, providing mocked APIs and examples through a single set of documentation. The format of this markdown documentation is API Blueprint format, for which the documentation and a rich set of parsing libraries and tooling has been released under the MIT license.