## The Handmaid's Tale

### Or, How to Successfully Oppress Women

Hulu just released three episodes of The Handmaid’s Tale, an adaptation of Margaret Atwood’s book of the same name. I binged watched it over the weekend, and I had some difficulty being immersed into it. There was something about the world that didn’t sit quite right with me in this adaptation, but I couldn’t quite put a finger on it. Eventually of course, I figured it out.

The story is set after the fall of the United States into Gilead. Not much is known about the world at this point, and so much is still up for speculation. However we the audience are entreated to these details:

• Pollution and toxicity is so bad that it caused fertility rates to drop.
• Congress was slaughtered, martial law was enacted.
• A theocracy hijacked the government under martial law.
• Communications between the populace and government is reduced - it would appear that the Internet doesn’t exist.
• Swift changes were made to the laws of the land, leading up to the scenarios we see in the show.

So what was it that made me unable to pay attention to the world building of the show? The speed at which things fell into place - it all happened within a few years of Offred’s lifetime.

## Deep Learning from Scratch in Go

### Part 1: Equations Are Graphs

Note: This post was originally published at GopherData. This blog post is the exact same copy.

Summary: In this post I talk about the basics of computations, then I go on to show parallels between Go programs and mathematical equations. Lastly I will attempt to persuade you that there is a point in using Go for doing deep learning.

Welcome to the first part of many about writing deep learning algorithms in Go. The goal of this series is to go from having no knowledge at all to implementing some of the latest developments in this area.

Deep learning is not new. In fact the idea of deep learning was spawned in the early 1980s. What’s changed since then is our computers - they have gotten much much more powerful. In this blog post we’ll start with something familiar, and edge towards building a conceptual model of deep learning. We won’t define deep learning for the first few posts, so don’t worry so much about the term.

There are a few terms of clarification to be made before we begin proper. In this series, the word “graph” refers to the concept of graph as used in graph theory. For the other kind of “graph” which is usually used for data visualization, I’ll use the term “chart”.

## New Blog

For about a month now, this blog has been a static site generated by Hugo. There had been a few issues with my wordpress installation at my previous host, and it left me unable to publish blog posts - they end up in “limbo” - some weird combination of plugins and tables. I had to hunt down all the posts I had published since the problem occured, and manually restore them. [Read More]

## What To Test

You’re in a rush. Your product demo was due three months ago. And you still don’t have good unit tests. What do you do? You prioritize.

You wrote a very complex piece of machinery with a lot of moving parts. You sorta know how they all fit together in your mind but there isn’t any good know if the program you wrote actually works the way you want it. The solution: unit testing. But how to test and where to start? What do you do? You prioritize.

This post is about how I prioritize what to test. I know how I write my programs, and I write them in a particular way. Feel free to adapt the following to your own process.

Since my program is made mostly of functions, I prioritize my tests by analyzing the function calls of the package/program. Some functions are called many times by different callers, some functions are top functions which calls other functions and outside of the package the top functions are never called. This forms a hierarchy of sorts - some calls are simply more important than others. Since I write mostly in Go nowadays, I’ll use Go as an example. The Go toolchain actually provide us with a lot of useful tools to analyze and prioritize tasks. The most important tool is the callgraph program. This is the invocation of the spell:

callgraph -algo=static -format=graphviz $(go list -tags=release -f '{{.GoFiles}}' | sed -ne 's/$//p' | sed -ne 's/$//p') | grep -P '\-\> "(PACKAGENAME|\(\*?PACKAGENAME\.)' | uniq > callgraph.dot  [Read More] ## A Direct Way of Understanding Backpropagation and Gradient Descent Summary: I believe that there are better representations of neural networks that aid in faster understanding of backpropagation and gradient descent. I find representing neural networks as equation graphs combined with the value at run-time helps engineers who don't have the necessary background in machine learning gets them up to speed faster. In this post, I generate a few graphs with Gorgonia to illustrate the examples. Backpropagation has been explained to death. It really is as simple as applying the chain rule to compute gradients. However, in my recent adventures, I have found that this explanation isn’t intuitive to people who want to just get shit done. As part of my consultancy (hire me!) job* really, I need to pay the bills to get my startup funded , I provide a brief 1-3 day machine learning course to engineers who will maintain the algorithms that I designed. Whilst most of the work I do don’t use neural networks* people who think deep learning can solve every problem are either people with deep pockets aiming to solve a very general problem, or people who don't understand the hype. I have found that most businesses do not have problems that involves a lot of non-linearities. In fact a large majority of problems can be solved with linear regressions. , recently there was a case where deep neural networks were involved. This blog post documents what I found was useful to explain neural networks, backpropagation and gradient descent. It’s not meant to be super heavy with theory - think of it as an enabler for an engineer to hit the ground running when dealing with deep networks. I may elide over some details, so some basic understanding/familiarity of neural networks is recommended. [Read More] ## Advent of Code/Go Apparently today is the start of Advent of Code/Advent of Go. I’m not exactly sure what they are (AoC seems to be a bunch of puzzles, AoG seems to be a bunch of blog posts). Nonetheless I think this is a good excuse for me to get busy writing blog posts every day, if only to trigger my writers’ block away. ## Numbers are Weird, Man Numbers are weird, man. I have an amateur interest in the history of maths*That is to say, I can't be arsed to actually invest time and energy to do serious research about it, but I am interested enough to retain knowledge about history of maths that I read - to the point that in my book about JavaScript, I had a small section devoted to the history of numerical representation., and I’ve been thinking about numbers lately whilst on a flight. [Read More] ## How To Make Money Hey Chewxy, what do you think will happen if one day everyone decides to move their money onto a blockchain and no longer need banks? That was a question that a friend asked me last week. I thought about the situation, gave some answers based on my what I understood of the world and the economy, while sketching out in broad strokes, what would happen. Essentially the conclusion was “civil unrest and war breaks out”* There were other conclusions too, I give the alternatives at the end of the blog post . Then came time to organize Sydney Python. Due to clashing meetup dates with Data Science Sydney, Girl Geek Sydney and other groups, there was a dearth of speakers. So I stepped up and gave a talk based on the hypothetical question. Here are the slides: The code can be found in this the economics simulation github repository. [Read More] ## Gorgonia I released Gorgonia on Thursday. Gorgonia is a library like Theano or TensorFlow, but mainly written in Go. It provides the necessary primitives for creating and executing neural networks and machine learning algorithms. According to cloc, these are the stats: [email protected]:~/workspace/goworkspace7/src/github.com/chewxy/gorgonia$ cloc .
357 text files.
321 unique files.
604 files ignored.

http://cloc.sourceforge.net v 1.60  T=0.83 s (296.5 files/s, 55471.5 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Go                             219           6308           3924          30858
Assembly                        22            585            740           2128
C/C++ Header                     2             55             57            666
C                                2             17             39            458
-------------------------------------------------------------------------------
SUM:                           245           6965           4760          34110
-------------------------------------------------------------------------------


So, it’s a pretty huge library. But the original version is about 80,000 LoC (though most of the lines of codes were different experimental variations of assembly code). I managed to cut down 50,000 LoC to something more manageable. In this post I want to outline the release of Gorgonia, and share some of the reasoning regarding the design of the library, as well as go thru some of the weirdness found in the library.