Kevin Sookocheff

Building your own Tool Calling Agent

Mon, 15 Jun 2026 05:41:48 +0000

Any sufficiently advanced technology is indistinguishable from magic.

— Arthur C. Clarke

At times I feel like Claude Code is this magical black box that I can give tasks to and get working code out of. This post attempts to shine a light on that black box by building our own agent harness around a model.

To do this, I will use Anthropic’s API to build a simple code review harness, showing how to take a simple chatbot interface into a fully featured developer application.

The Seven Powers of Platform Teams

Sun, 10 May 2026 09:18:32 +0000

I work on Workiva’s cloud platform engineering team, where we design and operate Kubernetes and AWS infrastructure supporting more than 300 microservices across multiple AWS regions. The platform spans networking, observability, CI/CD, compliance, and internal developer tooling. Lately, our team has been busy developing and codifying our strategy. I’m not a big fan of reinventing the wheel, and neither is the rest of our team, so we welcomed the opportunity to use existing business strategy frameworks and methodologies as a way to get started quickly. We used the Playing to Win Framework, and were able to flesh out a meaningful strategy focusing on things such as reducing cognitive load for development teams and streamlining how we report the customer impact of incidents.

Human in the Core, AI in the Shell

Thu, 02 Apr 2026 05:41:48 +0000

I, like many of you, am wrestling with how to best apply AI to my career as a software engineer. As we continue to adopt to AI-assisted coding, there is becoming more and more evidence that we may be limiting the ability of our future selves to own and support software systems.

In my last post, I made the argument that by writing this blog by hand, it forced a deeper understanding of the material, and resulted in something I was proud to call my own. Leveraging AI for writing removed both of these benefits, and stripped the satisfaction I get from having a blog in the first place.

Blogging in the Age of AI

Mon, 16 Mar 2026 05:41:48 +0000

This blog has been a part of my life for over fifteen years ago.

When I first started, I was inspired by Patrick McKenzie’s article Don’t End The Week With Nothing. This post left a memorable impression on 20-something me who had yet to consider what work really was — trading time and (sometimes) skill for money.

You work for a week, collect your paycheck on Friday, and then you and the company are even. If you are happy settling for even, that’s great. But then how can you get ahead? What would it take to finish a week with more than a break-even trade of time for money? Here I will quote Patrick verbatim:

Controlling a Korg Volca with the Akai MPK Mini Plus

Fri, 16 Jan 2026 09:21:32 +0000

In an attempt to move more of my music workflow off of my Mac and onto real hardware, I recently bought a set of used Korg Volca synthesizers for experimenting with synthesis and drum programming. I also have an Akai MPK mini plus that I mainly used for controlling Logic Pro that I wanted to repurpose for controlling the Volca synths through the MIDI out on the Akai MPK mini.

Since I couldn’t find any existing documentation of the process, I thought I would write it down myself in hopes of helping the next person working through this setup. This set of steps should be easily adaptable to both the MPK mini IV controller and other MIDI controllable synths or devices.

Cryptography for the Everyday Developer: Understanding RSA

Fri, 05 Dec 2025 10:52:43 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

Before the late 1970s, secure communication largely meant symmetric encryption. This included the complexity that comes with maintaining and sharing secrets every time two parties wished to communicate. RSA changed that by showing that encryption and decryption could use different keys, making secure communication practical for applications across the Internet.

Cryptography for the Everyday Developer: Number Theory for Public Key Cryptography

Tue, 07 Oct 2025 06:04:32 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

Modern cryptography relies heavily on number theory. One of the simplest but most important tools in the number theorist’s toolkit is the Euclidean algorithm. This algorithm, and its extension, the extended Euclidean algorithm, form the basis for practical cryptographic operations such as modular inversion. This blog post walks through both algorithms, with an explanation of why they are important to public key cryptography.

Why Three Replicas Are Better Than Two

Thu, 02 Oct 2025 09:40:16 +0000

When deploying microservices on Kubernetes, how many replicas should I run? Intuition suggests that two replicas is enough to give you high availability; if one pod dies, the other keeps the service online. Industry standard, however, suggests running three replicas. Why is this the case?

In this post, I will explain reasons to choose three replicas over two, and some best practices based on the realities specific to Kubernetes.

The Math Behind Preferring Three Replicas

The suggestion to run three replicas is often followed by hand-wavy “because it is more resilient”. Rather than rely on intuition, let’s try putting some numbers behind the reasoning.

Cryptography for the Everyday Developer: Double Encryption and the Meet in the Middle Attack

Wed, 24 Sep 2025 10:04:32 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

When the Data Encryption Standard (DES) was introduced in the 1970s, it was considered a solid block cipher. But DES has one major flaw by today’s standards — a small key space. With only 56 bits of key material, DES can be brute-forced with modern hardware by checking every possible key value. Once it was apparent that DES was no longer secure and could be brute-forced, a natural idea to extend the life of DES without resorting to an entirely new algorithm was to increase the size of the key space by encrypting the data twice with two different keys. The hope was that doubling the encryption operation with different keys would increase the difficulty of brute force attacks.

Cryptography for the Everyday Developer: Understanding AES - The Advanced Encryption Standard

Fri, 22 Aug 2025 09:08:32 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

Last time we explored the Data Encryption Standard (DES), and how its Feistel network structure worked. We also saw why DES eventually became obsolete: its 56-bit key size was simply too small in the face of modern computing power.

To replace DES, the U.S. National Institute of Standards and Technology (NIST) held a public competition in the late 1990s. Fifteen different algorithms were submitted from around the world. Over the course of several years, this field was narrowed down to five finalists, each carefully analyzed by cryptographers. Finally, in 2000, an algorithm called Rijndael, created by two Belgian cryptographers, Joan Daemen and Vincent Rijmen, was selected as the winner. This became the Advanced Encryption Standard (AES), which has since become the most widely used block cipher in the world. It is used everywhere: encrypting TLS traffic in your browser, securing Wi-Fi connections, and protecting classified government data.

Cryptography for the Everyday Developer: Understanding DES - The Data Encryption Standard

Fri, 18 Jul 2025 09:04:32 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

The Data Encryption Standard (DES) is based upon the principles of a substitution-permutation network that we learned about in the last post in this series. The design of DES is based on the principles of Feistel ciphers, which are a particular configuration of a substitution-permutation network developed by Horst Feistel at IBM.

Cryptography for the Everyday Developer: Confusion, Diffusion, and Substitution-Permutation Networks

Fri, 06 Jun 2025 09:04:32 -0600

This is an article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

A block cipher is a type if cipher that combines an encryption/decryption algorithm that works on blocks of data with a mode of operation that details the techniques to process sequences of data blocks.

While many different block cipher algorithms exist, they all share a common structural design: they apply a series of transformations — known as rounds — that iteratively manipulate the input data. These rounds consist of small, repeatable operations that gradually transform the plaintext into ciphertext.

Using V2 CloudFront Logs via CloudFormation

Thu, 22 May 2025 11:02:03 +0000

CloudFront supports two logging modes: v2 logging and legacy logging. Naturally, you’d expect to use the newer v2 logging—but if you’re provisioning CloudFront with CloudFormation, it’s easy to end up with the legacy setup by accident.

If you use the Logging property in your AWS::CloudFront::Distribution, CloudFormation will default to legacy logging, writing directly to S3. There’s currently no way to switch this to v2 via the Logging property in CloudFormation.

To enable v2 logging, you have to take a different approach:

Fixing display flicker for Dell monitors on Apple Silicon

Thu, 24 Apr 2025 06:14:23 +0000

If you have a Dell monitor and an M-series chip from Apple, you may have encountered flickering issues with your monitor which — at times — can render it completely unusable. The issue appears to be fairly widespread and can affect a number of Dell model and Apple silicon chip combinations, and has been acknowledged by Dell.

The flicker is caused by the monitors LCD panel’s Image Compensation Algorithm (ICA) function repeatedly turning On and Off. The YCbCr Video generated from the Macs is at 17Gray level, it fluctuates between 15Gary and 17Gary. Hence it is repeatedly turning On and Off, the ICA which has a threshold setting of 16Gray.

Cryptography for the Everyday Developer: Measuring Security in Bits

Thu, 20 Mar 2025 10:04:32 -0600

This is the fifth article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

When discussing encryption, you’ll often hear talk about the strength of a security system as measured in “bits.” For example, systems might advertise their strength as having 128-bits or 256-bits. But what exactly does security measured in bits mean? Let’s demystify this common yet sometimes misunderstood concept.

Cryptography for the Everyday Developer: Modular Arithmetic

Mon, 17 Mar 2025 10:04:32 -0600

This is the fourth article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

Modular arithmetic is the foundation for asymmetric cryptography like RSA, elliptic curves, or Diffie-Hellman — all of them rely on the properties of modular arithmetic to guarantee security and secrecy.

Since modular arithmetic is so important to cryptography, it pays to understand how it works. This post will help us along the journey by demystifying modular arithmetic, explaining how it works, and why it matters for cryptography.

Cryptography for the Everyday Developer: Random Number Generators

Fri, 14 Feb 2025 10:52:43 -0600

This is the third article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

Without randomness, cryptography would be impossible because all operations would become predictable and therefore insecure.

— Jean-Philippe Aumasson, Serious Cryptography

The cryptographic strength of most systems lies in their ability to generate random numbers that cannot be easily guessed or reproduced, making it difficult for adversaries to crack the encryption or predict the output. Unfortunately for us, computers and the software that they run are very predictable. As long as they are given the same inputs each time, they’ll always come up with the same outputs. This is very good for reliability, but not so good for cryptography where randomness and unpredictability are required for secure operation.

Cryptography for the Everyday Developer: Security Goals

Tue, 28 Jan 2025 10:52:43 -0600

This is the second article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

A cipher is only useful if it is secure. What makes a cipher secure? Let’s remember the use case for classical ciphers — keeping messages confidential.

Caesar’s cipher and Vigenère’s cipher both suffer from a similar flaw, which makes them insecure and unusable for secure communication. For both ciphers, the flaw is obvious — these ciphers allow an attacker to learn how the cipher works by inspecting the ciphertext itself. This allows an eavesdropper can decrypt the message given only the ciphertext. A secure cipher, on the other hand, is one where it is not possible to learn anything about the plaintext or the cipher’s behaviour even by inspecting numerous plaintext or ciphertext messages.

Cryptography for the Everyday Developer: Encryption Basics with Classical Ciphers

Wed, 22 Jan 2025 10:04:32 -0600

This is the first article in a series on Cryptography for the Everyday Developer. Follow along to learn the basics of modern cryptography and encryption.

The best way to begin learning about encryption is by example. And thankfully, there exist many examples of encryption throughout history that we can draw from. One of the earliest well-known examples of encryption is the Caesar Cipher, and we will begin there.

The Caesar cipher is one of the oldest and simplest forms of encryption. It works by shifting each letter in your message a fixed number of positions down the alphabet. For example, with a shift of 3:

Clustering a DSM Using Simulated Annealing

Fri, 10 Jan 2025 05:48:21 -0600

In this blog post, we will explore how to use simulated annealing to cluster a Design Structure Matrix (DSM). We will also discuss how this approach differs from the implementation developed by Ronnie Thebeau as part of his master’s thesis.

What is a Design Structure Matrix (DSM)?

A Design Structure Matrix (DSM) is a compact, matrix representation of a system or project. It is used to model the relationships between elements in a system, such as tasks in a project or components in a product. Each row and column in the matrix represents an element, and the cells indicate the presence and strength of relationships between elements.

In the Cloud, Cost is Everything

Tue, 17 Dec 2024 12:49:38 +0000

At AWS re:Invent 2023, Amazon CTO Werner Vogels delivered a talk on the laws of frugal architecture. While I initially filed away those insights to review later, a year of cloud architecture experience crystallized a fundamental truth: in cloud computing, cost isn’t just a financial consideration — it is a first-class architectural concern through which we should design and optimize our systems.

Cloud providers charge for every conceivable resource: servers, API calls, data transfer, and computational milliseconds. But cost is more than just a line item on a monthly bill, it is a powerful forcing function that drives better architectural decisions.

The Developers Guide to FIPS 140 Compliance

Thu, 06 Jun 2024 11:15:08 +0000

If you work with US government entities or corporations in regulated markets the subject of FIPS compliance may come up, especially in the context of FedRAMP authorization. FIPS 140-2 and FIPS 140-3 are a set of cryptographic standards that your application may need to adhere to dictating the appropriate ciphers or cryptographic functions that are in use.

It can take a lot of effort to run a completely FIPS compliant architecture, but for application developers, the bottom line is that any code that uses cryptographic operations to secure customer data must use FIPS certified cryptographic libraries.

Near infinite scaling with the scale cube and cell-based architecture

Tue, 28 May 2024 03:38:23 +0000

Most new applications are built as a single codebase and deployed as a monolith until product-market fit or the need for additional scale is required. Such monolithic applications are easy to write and maintain, and allow you to iterate quickly when there are a smaller number of users and the traffic is low. However, as traffic increases you will need to scale the application to handle the increase in load. One framework for scaling is the “Scale Cube” describe by AKF partners.

Developing an Aya-rs eBPF application using devcontainers

Wed, 08 May 2024 10:14:21 -0600

eBPF is a technology allowing you to dynamically program the kernel using a virtual machine approach. Several development frameworks exist, with the top choice for Rust developers being Aya.

Because of the deep integration between eBPF and the Linux kernel, it can be challenging to create a local development environment that works across different development machines. To date, I’ve taken to developing eBPF programs on EC2 instances using the AWS Cloud9 development environment. This works, but comes with its own issues and won’t be for everyone.

Building a FIPS Compliant Kubernetes Cluster on AWS

Thu, 18 Apr 2024 11:59:15 +0000

One of the larger hurdles to climb when becoming FedRamp moderate is encrypting all data in transit using FIPS validated encryption modules. This article describes one approach to satisfying this requirement for anyone running a Kubernetes cluster on AWS.

For those lucky souls who are unfamiliar with FIPS, it stands for Federal Information Processing Standard (FIPS), which is a joint US and Canadian government standard that specifies the security requirements for cryptographic modules that protect sensitive information. FedRamp specifically requires you to satisfy two related controls: SC-8 and SC-13.

Surveying the eBPF Developer Ecosystem

Fri, 22 Mar 2024 05:48:21 -0600

This article provides guide to the different developer tools available for writing eBPF programs, covering the core tools BCC, bpftrace, ebpf-go, and libbpf.

These tools satisfy a different use case depending on whether you are trying to use eBPF for running analysis scripts, or full-fledged programs, in what programming language you wish to use, and the maturity and feature parity with the most recent eBPF features in the Linux kernel.

Unfortunately, there is no single definitive guide to BPF and there is still a lot of unwritten knowledge, though some of the resources provided in this article may help you get started on your own journey.

Routing Users to a Login Page Based on Geolocation

Tue, 12 Dec 2023 11:42:33 +0000

A common pattern when scaling a SaaS application is to deploy your stack to multiple regions across the globe. Deploying to multiple regions helps distribute the application and data closer to the user, and isolates infrastructure in case of an outage in a single region. If your application is deployed in this configuration, you have the new problem of routing users to the correct region based on their tenancy or geography. This post shows how to create a global login portal that directs users to the correct local region where they can access their application.

What is eBPF and Why is it Important?

Mon, 04 Dec 2023 05:48:21 -0600

A short tagline from the book Learning eBPF describes eBPF as

a revolutionary kernel technology that allows developers to write custom code that can be loaded into the kernel dynamically, changing the way the kernel behaves.

The key word in this phrase is dynamically. eBPF allows you to write custom code that changes the way the kernel behaves without having to implement a kernel module or integrate your code directly into the kernel.

Disaster Recovery with DynamoDB Global Tables

Mon, 20 Nov 2023 11:59:15 +0000

DynamoDB provides built-in support for cross regional data replication using a solution AWS calls global tables. This article shows how to build and run an application in Kubernetes that uses global tables to replicate data between regions. In the event of a regional disaster, a secondary Kubernetes cluster in a secondary region has all the data from DynamoDB replicated locally to continue operation.

How global tables work

A DynamoDB global table is a set of multiple replica tables. Each replica table exists in a different AWS region, but all replicas have the same name and primary key. Whenever data is written to any replica table, the data is automatically replicated to all other replica tables that have been added to the global table.

Supporting disaster recovery with a multi-region EKS deployment

Thu, 09 Nov 2023 10:14:21 -0600

Disaster events are one of the biggest challenges that a software organization can face. Natural disasters like earthquakes or floods, technical failures such as power or network loss, and human actions such as unauthorized attacks can disable an entire fleet of systems, leading to complete failure for a business. To deal with disaster scenarios requires a proactive approach to prepare and recover from failure.

One of the key benefits of running in the cloud is how easy it is to run workloads in multiple regions. This allows you to deploy a resilient architecture that supports disaster recovery, even in the cases where an entire region is disabled.

FSBench: A filesystem benchmarking utility

Fri, 22 Sep 2023 13:17:49 +0000

Check out the project on Github.

I recently published a new project for repeatable filesystem benchmarking. This code is based on the benchmarks available in the AWS Mountpoint-s3 project and the Flexible I/O Tester, made into a more general purpose utility for benchmarking arbitrary filesystems.

The benchmark consists of a mix of read and write workloads, each run for ten iterations. The average result of the ten iterations is reported as the final result of the benchmark.

Benchmarking AWS CSI Drivers

Tue, 19 Sep 2023 10:27:12 +0000

AWS provides four different storage options for your Kubernetes cluster: EBS, EFS, FSx for Lustre, and Amazon File Cache. Each of these CSI drivers has different performance characteristics, depending on your workload. This post quantifies those performance differences using the flexible I/O tester FIO.

Note: For an overview of the different CSI options available on AWS, see Picking the right AWS CSI driver for your Kubernetes application.

Before we start, please note that these results come with multiple caveats, and you should absolutely test performance on your own workloads before making any final decisions. For example, a workload with many random reads is typically latency sensitive and would benefit from higher IOPS, whereas a workload consisting of mostly streaming reads is typically throughput sensitive and would benefit from higher bandwidth and at large I/O sizes with relatively lower IOPS.

Picking the right AWS CSI driver for your Kubernetes application

Tue, 12 Sep 2023 06:44:23 -0600

Dealing with storage is a core challenge when running complex applications on Kubernetes. While many applications operate just fine using a cloud database or blob storage, some applications have performance or design requirements requiring local storage.

Note: For performance benchmarks see [Benchmarking AWS CSI Drivers](<{{ relref “/post/kubernetes/benchmarking-aws-csi-drivers” }}).

When this is the case, developers and cluster operators rely on Container Storage Interface (CSI) implementations to provide local storage for Pods. When running on the AWS cloud, no less than four CSI providers are available for us to use: Elastic Block Storage, Elastic File System, FSx for Lustre, and AWS File Cache. This article compares these four different local storage options to help you choose the right option for your application.

Leveraging eBPF in the Kubernetes Networking Model

Mon, 21 Aug 2023 03:48:31 -0600

eBPF is a relatively new extension of the Linux kernel that can run sandboxed programs in a privileged context. It is used to safely and efficiently extend the capabilities of the kernel at runtime without requiring changes to kernel source code or the loading of kernel modules.

Because of eBPFs tight integration with the networking stack at the kernel level, it is seeing adoption in networking applications. This includes Kubernetes networking through eBPF implementations of the Kubnernetes networking stack like Cilium.

Trust your users — they’re usually right

Mon, 29 May 2023 12:20:12 -0600

I was recently introduced to a simple article on system design: Users are almost always right. In it, a simple rule is stated:

When the users keep doing it wrong, the users are right and your system is wrong.

This rule reminded me of the concept of desire paths: unplanned trails created by human or animal traffic that usually represent the shortest or easiest route between two places. Desire paths in an urban setting often run counter to what a planner might suggest, leading to a natural conflict between the pedestrian and the planner.

Generating Large Test Files

Wed, 24 May 2023 09:58:13 +0000

I was recently testing file upload performance, and needed several large files of different sizes to test with. To make the math easier, it was helpful if I had files with round numbered sizes like 10MB, 20MB, or 100MB. After searching around for files of the right size, it turns out the easiest solution is to generate one yourself using the Linux command line.

Depending on your needs, you can use two different methods of generating files using some simple commands.

Generating JSON Web Token Assertions

Thu, 11 May 2023 14:39:13 +0000

A JWT (JSON Web Token) is a type of security token that is used to securely transmit information between parties. It is a compact and self-contained way of representing claims to be transferred between two parties. Many API providers require you to generate a cryptographically signed JWT assertion that includes the authorization you are requesting from the server. If the server accepts the assertions you are claiming in the JWT, it will respond with an access token granting access to the API.

Tackling Technology Strategy with Portfolio Management

Thu, 27 Apr 2023 08:51:15 +0000

Application Portfolio Management (APM) draws inspiration from financial portfolio management, which has been around since at least the 1970s. By looking at all applications and services in the organization and analyzing their costs and benefits, you can determine the most effective way to manage them as part of a larger overall strategy. This allows the architect or engineering leader to take a more strategic approach to managing their application portfolio backed by data. Portfolio management is crucial for creating a holistic view of your team’s technology landscape and making sure that it aligns with business goals.

Making Sense of Kubernetes Metrics

Fri, 24 Mar 2023 08:44:23 -0600

Shortly after deploying a new Kubernetes cluster, one of the first things you will likely want to do is collect some metrics and data about how it operates. There are two projects that are typically used for this, and since they are named similarly it can be confusing to know which one you should use and why.

This post hopes to clear up any confusion between the Kubernetes Metrics Server and kube-state-metrics.

Project Management for Software Engineers

Wed, 08 Mar 2023 08:01:52 -0600

At some point in your career you will be asked to manage a project. This can be intimidating, it can be scary, but it doesn’t have to be. We can leverage some time-honoured techniques, and adapt them to the unique approach required for software projects to deliver on time, on budget, and with success.

This article is a collection of techniques I’ve learned for managing projects over time, that attempts to combine agile best practices with project management best practices. If you study project management to any level of depth, it is inevitable that you will come across the Project Management Institute, or PMI. The PMI is a global professional body that provides training and certification in project management topics. PMI provides different certification options, including some for Agile processes and Scrum.

Increased virtualization performance with the AWS Nitro System

Wed, 21 Dec 2022 11:59:15 +0000

Amazon’s Elastic Compute Cloud (EC2). EC2 is a web service that provides resizable, on-demand computing capacity — literally, servers in Amazon’s data centers — that you use to build and host your software.

It’s important to understand that EC2 is a virtual computing environment. In a virtual environment, there is one physical server with all of the necessary hardware — CPU, memory, hard disk, network controller and more. This single physical server can host multiple operating systems and applications through a hypervisor that runs directly on top of the physical machine. The following simplified diagram shows a hypervisor architecture based on the Xen project: Xen interfaces directly with the hardware, and has a special control domain (dom0) for interfacing with Xen. Domain 0 is designed to access hardware directly and manage devices and device drivers. It has the ability to talk to the hypervisor to instruct it to start and stop guest VMs.

Using Neovim as a Java IDE

Wed, 14 Dec 2022 09:22:09 -0600

I first learned Vim in university and, since then, it has been a welcome companion for the majority of my software engineering career. Working with Python and Go programs felt natural with Vim and I was always felt productive. Yet Java was always a different beast. Whenever an opportunity to work with Java came up, I would inevitably try Vim for a while, but fall back to IntelliJ and the IdeaVim plugin to take advantage of the rich language features a full-featured IDE can give you.

Distributed System Models in the Real World

Tue, 20 Sep 2022 09:16:09 -0600

Practical distributed applications are deployed into varied environments and execute on a variety of different machines linked together over a variety of communication infrastructure. The physical machines themselves can differ in the number and speed of processors, the availability of random access and stable storage, and more. The communication infrastructure can differ in the available levels of latency, throughput, and reliability. Because of these differences, it is more practical to look at distributed algorithms from a higher-level perspective so that they are applicable to a wide range of environments. Such algorithms do not depend on the particular details of the hardware or software on which they are run, and they are not limited to a highly specialized implementation.

Write-ahead logging and the ARIES crash recovery algorithm

Fri, 26 Aug 2022 05:21:37 -0600

A central tenet of databases is that any committed data survives a crash or a failure. Write-ahead logging is a fundamental primitive that ensures all changes to data are first written safely to stable storage before being applied. Coupling that with some careful use of sequence numbers and we can guarantee that changes made to a database can survive system crashes.

Motivation

Let’s start with a simple transaction T1 that reads object A, and updates the value for A with a write. To simplify matters, A is stored on disk as a single page as in Figure 1.

How to kill a process that is a using port on macOS

Wed, 29 Jun 2022 09:24:57 +0000

Every so often I get stuck with a running process that’s using a specific port, preventing me from running some new application that uses the same port. Then I’m left Googling for solutions or rebooting the machine to make progress. But not any more! I’m recording the solution for my future self (and of course for you, dear reader).

> sudo lsof -i :<PortNumber>  # returns list of processes using the port, with PID

> kill -9 <PID>  # kill the specific pid

For example, you can find out what’s running on port number 8080 by running the command:

Progress is a lake, not a line

Wed, 01 Jun 2022 12:30:23 +0000

When people describe progress, they often describe it in terms of a linear progression taking us from primitive to advanced — an idea or invention occurs as a singular event, and somewhere further down the line of time a new idea or invention completely replaces it, relegating the old to the annals of history.

This viewpoint is exemplified by traditional worldviews that organize all beings according to a chain of evolution, sometimes called the “great chain of being” (or scala naturae). The chain of being links God, angels, humans, animals, plants, and minerals in a hierarchy. All beings on earth, animate and inanimate, could be organized according to an increasing scale of perfection, from mushrooms and rocks at the bottom up through lobsters and rabbits, all the way to human beings and God at the top.

Why Systems Work So Well

Wed, 11 May 2022 05:48:21 -0600

In the book “Thinking in Systems”, Donella Meadows dedicates an entire chapter to explaining why functioning systems seem to work so well. In it, she recognizes three characteristics: resilience, self-organization, and hierarchy.

Resilience

We can use the standard definition from the Oxford English dictionary to describe resilience:

re·sil·ience /rəˈzilyəns/ noun

the capacity to recover quickly from difficulties; toughness. “the often remarkable resilience of so many British institutions”

the ability of a substance or object to spring back into shape; elasticity. “nylon is excellent in wearability and resilience”

According to Donella Meadows this definition can be translated to systems as the “ability to survive and persist within a variable environment. The opposite of resilience is brittleness or rigidity.”

Java For The Experienced Beginner

Wed, 27 Apr 2022 08:31:12 -0400

Java was the first programming language I was taught at University, and the language I used for the first decade of my career. It continues to be a reliable companion throughout my software development career. Unfortunately, not having developed with Java professionally for several years, I’ve found there are many aspects of the modern Java language that I’m simply not familiar with. To rectify this, I’ve collected the major improvements to the language beginning with Java 8, combined with a short explanation of how they work and how to use them. It assumes you know Java, but don’t really know Java. Hopefully, it can take you from experienced beginner to just plain experienced again.

Behaviour Parameterization

Tue, 26 Apr 2022 07:37:12 -0400

One of the core features of modern Java is lambda expressions. Introduced in Java 8, lambdas provide concise syntax allowing the deferred execution of a block of code. Put a different way, lambdas allow us to pass behaviour as a method parameter. When the method executes, the lambda expression is run. This capability is often referred to as behaviour parameterization.

Behaviour parameterization can be achieved in a number of ways, of which lambda expressions are usually the most convenient, and they are definitely the most concise. But what is behaviour parameterization, and why would we want to use it? To motivate this discussion, let’s work through a real-world example of filtering a list of items according to some criteria. More concretely, let’s investigate the problem filtering a list of students to find the ones with the best grades.

What complex systems can teach us about building software

Wed, 09 Mar 2022 08:10:16 +0000

As a software system scales it becomes sufficiently large that the number of working parts, coupled with the number of working programmers making changes on it, makes the behaviour of the system extremely difficult to reason about. This complexity is exacerbated by the transition of many organizations towards a microservice architecture, as exemplified by the so-called “death star” architecture, where each point in the circumference of the circle represents a microservice and the lines between services represent their interactions.

Hybrid Logical Clocks

Mon, 24 Jan 2022 06:16:09 -0400

The theory of distributed systems promoted the use of logical clocks by introducing the idea of causality tracking as an abstraction for reasoning about concurrency between events in the system. In practice, a lot of systems continue to operate using physical time, which presents difficulties due to clock synchronization drift. In an effort to bridge the gap between physical and logical time, HybridTime combines both logical and physical times in one system.

Hybrid Logical Clocks (HLC) are extensions of the previous causality and time keeping systems that capture the causality relationship like logical clocks, but that can also substituted for physical clocks by maintaining its logical value always close to NTP. With these semantics, HLC can be used in lieu of a physical clock source like NTP for database reads, and it can simultaneously be used as a logical clock to identify consistent global snapshots.

HybridTime

Tue, 11 Jan 2022 06:16:09 -0400

HybridTime introduces a hybrid between physical and logical clocks that can be used to implement globally consistent database snapshots. HybridTime is one implementation of the general concept of Hybrid Logical Clocks that combine the logical clock semantics of Lamport and Vector clocks with a physical representation of time such as Spanner’s TrueTime.

HybridTime follows similar update semantics as Lamport and Vector Clocks, where each node in the system updates their internal clock in response to events received. It differs in that HybridTime values are not purely logical — they include a physical time component that allows values to be associated with a physical point-in-time.

TrueTime

Thu, 23 Dec 2021 06:16:09 -0400

TrueTime is Google’s solution to providing to globally consistent timestamps to determine ordering of events. Originally developed to support the Spanner distributed database, TrueTime is a clock implementation that depends on two key factors: well engineered and accurate GPS and atomic clocks and the representation of time as an interval of uncertainty.

Representing TrueTime

TrueTime explicitly represents each timestamp an interval that includes bounded time uncertainty. TrueTime represents time as an interval of the type TTinterval, which includes two timestamps for the beginning and the end of the interval. These timestamps have type TTstamp. With this in mind, the TrueTime API provides the following methods reproduced from Spanner: Google’s Globally-Distributed Database:

Vector Clocks

Mon, 20 Dec 2021 06:16:09 -0400

Vector clocks are an extension of Lamport Clocks designed to determine all correct orderings of events in a distributed system. Whereas Lamport Clocks yield one of the many possible event orderings, this does not for certain classes of problems that require knowledge of global program state such as reversing the order of execution to recover from errors or rollback. In such cases, it is more useful to have access to the entire set of orderings that are causally consistent at any moment in time. Vector clocks are designed for exactly such cases.

Lamport Clocks

Wed, 08 Dec 2021 06:16:09 -0400

Computers generally track the current time using a quartz crystal that oscillates at a known frequency. This frequency is used to advance the local clock at pre-defined intervals. Quartz oscillates with enough stability that it can be used to maintain time within a few milliseconds of accuracy per day. Over time however, these imperfections can accumulate, making the clock inaccurate. To fix these inaccuracies, computers typically run a background process like NTP to synchronize the local clock with servers that are known to be accurate.

How Does NTP Work?

Tue, 23 Nov 2021 06:16:09 -0400

The Network Time Protocol (NTP) is a system for synchronizing the clocks of hosts and clients across the Internet. NTP is a protocol intended to synchronize all computers participating in the network to within a few milliseconds of Coordinated Universal Time (UTC). The core of the protocol is NTP’s clock discipline algorithm that adjusts the local computer’s clock time and tick frequency in response to an external source — such as another trusted NTP server, a radio or satellite receiver, or a telephone modem. A core problem in NTP is establishing the trust and accuracy of nodes in the NTP network. This is done through a combination of selection and filtering algorithms to choose from the most reliable and accurate peer in the synchronization network.

Local Kubernetes Development with microk8s

Fri, 24 Sep 2021 09:44:23 -0400

Still in search of a Kubernetes development environment I can run on my development machine that somewhat replicates, I was recently introduced to both the multipass and microk8s projects from Canonical.

multipass is a prerequisite for microk8s, so let’s start there. With multipass, you can easily launch and run Ubuntu virtual machines with a single command.

❯ multipass launch --name foo

Launched: foo

With a virtual machine in hand, you can run execute arbitrary commands on the machine using the exec subcommand.

Why Foxes Make Better Decisions Than Hedgehogs

Thu, 15 Jul 2021 08:01:52 -0600

The ancient Greek poet Archilochus wrote that “the fox knows many things, but the hedgehog knows one big thing.” In social psychology, these terms have been used as a shorthand for describing two cognitive styles: foxes, who are comfortable with nuance, can live with contradictions, and have different strategies for solving different problems, and hedgehogs, who focus on the big picture, reduce every problem to one organizing principle, and solve problems through that singular lens.

Connecting Technology to the Needs of the Business

Mon, 21 Jun 2021 06:59:15 +0000

All healthy technology discussions should begin with business goals and use those goals as a reasonable set of guidelines to focus technology investment decisions. These business goals are best articulated from a deep understanding of what the company, the product team, or the marketing team want to accomplish.

In a business-first model, technology is forced to balance the desires for technical effectiveness and efficiency with the operational needs of the business. This balance can be difficult to achieve if you’ve ended up in a leadership position from a technology background — you are used to solving problems by writing code and it becomes difficult to think of other ways to solve them!

The False Dichotomy of Design-First and Code-First API Development

Tue, 08 Jun 2021 05:46:53 +0000

In creating a development workflow for releasing HTTP+JSON APIs, many teams settle on the API description and documentation standard OpenAPI. A natural conversation that takes place after settling on OpenAPI is whether or not you should develop your API using a “design-first” method or a “code-first” method. I believe that narrowing the discussion to these two extremes overly simplifies the discussion. Instead, I prefer to talk about API development as a continuum of development process that revolve around the prominence of the API description document in the process.

The Most Important Criteria for Choosing a Programming Language

Thu, 20 May 2021 08:01:52 -0600

One of the recurring themes of any technology discussion is programming language. It doesn’t take much effort to find blog posts with dramatic headlines (and even more dramatic comments) about how shipping a new project with Haskell or Clojure or Elm improved someones job, marriage, and life. These success stories are posted by raving fans that have nothing but the best to say about their language of choice. A common thread running through these posts is that they are typically tied to building out new, greenfield projects. I can’t help but wonder. After the honeymoon of building a new project with a new programming language, what happens next? Is it all bubble gum and roses?

Augmenting Spring Data REST with Additional Endpoints

Wed, 19 May 2021 08:01:52 -0600

Spring Data REST combines the features of Spring Data with Spring HATEOAS to make it easy to build hypermedia-driven REST APIs on top of Spring Data repositories. The basic functionality provided out of the box creates and exposes simple REST endpoints for performing CRUD operations on Spring Data repositories. For a lot of use cases, this is entirely enough functionality to meet your needs. In other cases, you need to extend the REST API to include additional functionality that isn’t provided by Spring Data REST and it can be difficult to determine exactly how to do this. In this blog post, I show you how to augment a Spring Data REST API with additional endpoints to turn a basic CRUD API into a full featured web service.

Making Modular Monoliths Work

Thu, 18 Feb 2021 09:40:16 +0000

Microservices have become part of the software engineering cultural zeitgeist to the extent that alternative approaches to architecture and development are treated as somehow inferior. Given the challenges that running microservices present, I usually recommend beginning development of new projects and systems as a single deployable unit — the monolith.

Sam Newman, in the book “Building Microservices”, agrees with this approach. He recommends leveraging microservices only if you can become convinced of the benefits for your system, not as a default for every project.

Unpacking the eight fallacies of distributed computing

Thu, 11 Feb 2021 09:16:09 -0600

When building and running a system deployed as a monolith, we are able to make a certain set of assumptions about the behaviour of the overall application. One of the biggest assumptions we make is that the memory space for the application all resides on the same machine. With this model, function and library calls can assume that their view of the data structures for the application are accurate, and that you can retrieve or mutate that data immediately and deterministically (leaving the thornier issues of multi-threaded applications aside for a minute). These assumptions allow teams of programmers to work effectively and efficiently across multiple packages, libraries, classes and functions.

Handling the rudder as an organization grows

Fri, 15 Jan 2021 05:03:32 +0000

In a shopping cart, the swivel wheels of the cart are set in the front, and the fixed wheels are set in the back.

Now picture yourself pushing a shopping cart backwards. Almost naturally, you swivel the cart to move the front end to one side or the other before beginning to push the cart. Now picture yourself pushing a shopping cart backwards, on an ice rink. Here, the cart keeps sliding around even after you’ve stopped pushing it. Instead of going straight from one end of the rink to the other, the cart makes giant S-shaped turns.

The Cathedral, The Bazaar, and the API Marketplace

Fri, 11 Dec 2020 11:16:53 +0000

In The Cathedral and the Bazaar, Eric Raymond recounts the early years of Linux. Specifically questioning how the “part-time hacking of several thousands of developers scattered all over the planet” could create perhaps the most complex, functioning application in history. How could a “babbling bazaar of differing agendas and approaches” coalesce into a coherent and stable system without some form of centralized planning?

The fact that this bazaar style seemed to work, and work well, came as a distinct shock. As I learned my way around, I worked hard not just at individual projects, but also at trying to understand why the Linux world not only didn’t fly apart in confusion but seemed to go from strength to strength at a speed barely imaginable to cathedral-builders.

Marrying RESTful HTTP with Asynchronous and Event-Driven Services

Tue, 24 Nov 2020 12:16:18 +0000

Many organizations have multiple applications that are being built independently as a microservices-based platform. By its nature, a microservice platform is a distributed system running on multiple processes or services, across multiple servers or hosts. Building a successful platform on top of microservices requires integrating these disparate services and systems to produce a unified set of functionality.

It is naïve to think that we can only choose one communication style to solve all problems; if integration needs were always the same, there would be only one style and we would all be happy with it. In reality, a single service can can communicate using many different styles, each one targeting a different scenario and goals. This challenge is what brings me to the topic of this blog post: when and why do we use different communication standards?

Running a Dapr Application on Kubernetes

Fri, 23 Oct 2020 10:09:59 -0600

With so many people running microservice workloads, it is inevitable that organizations keep bumping into the same set of problems: state management, resiliency, event-handling, and more. Dapr exists to help codify the best practices for building microservice applications into building blocks that enable you to build portable applications with the language and framework of your choice. Each building block is completely independent and you can use one, some, or all of them in your application to solve common microservice problems.

Local Kubernetes Development with Tilt

Mon, 05 Oct 2020 08:44:23 -0600

In my last post I detailed how to setup a local Kubernetes development cluster using kind. This post shows how to leverage this new cluster when developing a system or application that relies on multiple microservices using tilt. If you haven’t setup your local environment with kind yet, refer back to my last post before continuing on.

Installing Tilt

You can install the tilt binary using Homebrew or through curl and an installation script:

Local Kubernetes Development with kind

Mon, 28 Sep 2020 11:44:23 -0600

kind is a tool built for running local Kubernetes clusters using Docker containers as nodes. kind was primarily designed for testing Kubernetes itself, but it is actually quite useful for creating a Kubernetes environment for local development, QA, or CI/CD. This blog post shows you how to setup a kind-based environment for local development that can mimic a production Kubernetes environment.

A fully functioning environment using kind includes a few different components. For our purposes, we will install the following list of software.

There and Back Again: The Unexpected Journey of a Request

Tue, 18 Aug 2020 06:54:45 +0000

It’s a dangerous business, Frodo, going out your door.

Kubernetes and public cloud infrastructure introduce a few layers of abstraction between users and our services. This article unravels some of those layers to help understand what, exactly, happens between the time a user makes a request to a Kubernetes service running in AWS and when the user receives a response. It’s helpful to start by framing a request in terms of the network boundaries involved, so let’s start there.

VoltDB

Wed, 03 Jun 2020 06:00:31 -0600

VoltDB is an in-memory database borne out of the H-Store research project spearheaded by Michael Stonebraker. Within that project, Michael started with the premise of building a fully transactional database with the best possible performance by using insights gathered from an in-depth study on database performance that completely removed disk access — the primary limiting factor on database performance. By removing disk access completely, we end up with a completely in-memory database where we can make additional optimizations like removing write-ahead logging, buffer management, and locks and latches. This effort resulted in the research database H-Store which was commercialized as the in-memory database VoltDB. This article takes a deeper dive into VoltDB to understand how it works and where you may benefit from this approach.

Understanding Spring's Environment Abstraction

Wed, 27 May 2020 09:57:12 -0600

When working with Spring Boot, some auto-configuration can happen seemingly by magic. For example, in a traditional Spring application with Java-based configuration, you might configure an H2 database using the following block of code to set the type of the database and run some scripts to initialize it:

@Bean
public DataSource dataSource() {
    return new EmbeddedDataSourceBuilder()
        .setType(H2)
        .addScript("taco_schema.sql")
        .addScripts("user_data.sql", "ingredient_data.sql")
        .build();
}

With Spring Boot, you can remove this entire block of code and use auto-configuration. If the H2 dependency is available in the classpath, Spring Boot will automatically create the DataSource and add it as a Bean to Spring’s application context and apply SQL scripts as long as they are named schema.sql or data.sql. Spring Boot does this auth-configuration by leveraging the Spring environment that collects the set of properties available to a Java application and uses those properties to configure beans in Spring’s application context. The following figure from Spring in Action shows how the Spring environment is generated by some of the available configuration property sources available in a typical Java application.

What is the OCaml toplevel?

Fri, 22 May 2020 08:13:12 -0600

Many OCaml guides and tutorials refer to the OCaml toplevel, but what exactly is this thing? In short, the toplevel is OCaml’s Read-Eval-Print-Loop (repl) allowing interative use of the OCaml system. You can consider the toplevel an alternative to compiling OCaml into an executable. In this mode, the OCaml system is configured to repeatedly read phrases from input, typecheck, compile, and evaluate them, then print the inferred type and result value.

Building a Modern Java Web App with Spring Boot

Wed, 20 May 2020 09:13:12 -0600

I’m a fan of Java. If you haven’t given it a chance in a while, you may not have noticed that, Java has quietly been adopting some of the best practices that make dynamic and functional languages so appealing, without sacrificing the many hundred person-years of effort that have made Java and the JVM a world-class development environment. Java is still one the world’s most popular programming languages with roughly 9 million programmers using Java. It doesn’t make sense to ignore all of that history and development effort because of a niggling feeling that Java is a little too verbose, or that XML is so last year.

Inversion of Control, Dependency Injection, and the Spring IoC Container

Thu, 14 May 2020 09:13:12 -0600

Inversion of Control (IoC), also known as Dependency Injection (DI), allows an object to define their dependencies as constructor arguments (strictly speaking, you can set these dependencies as properties, but the examples I will use today are constructor-based). This is the inverse of the object itself controlling the instantiation or location of its dependencies, hence the name Inversion of Control.

Let’s look at an example from Stackoverflow using a text editor with a spell checking component:

Starting a new OCaml project using Dune and Visual Studio Code

Tue, 12 May 2020 11:13:12 -0600

After recently setting up a new machine and going through the exercise of setting up a development environment for the nth time, I was frustrated by having to install and configure all of my plugins and dependencies to support auto-completion, syntax highlighting, and the other niceties I’ve come to enjoy with Vim. Looking for an alternative, I was drawn to Visual Studio Code (VS Code) with the VSCodeVim extension. Combining Vim key-bindings with Code’s excellent extension marketplace, I was able to recreate and in some cases improve the development environment I enjoyed as a Vim user in VS Code. This blog post continues that discovery by setting up a brand new OCaml project and development environment in VS Code.

A Tour Through OCaml with Project Euler

Fri, 08 May 2020 09:13:12 -0600

This post covers some of the major features of OCaml while solving Problem 1 from Project Euler.

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Let’s get started on this problem by looking at the math facilities provided by OCaml. Start a new interactive session using utop.

Getting Started with opam, the OCaml Package Manager

Mon, 04 May 2020 11:13:12 -0600

opam — the OCaml Package Manager — is the tool for installing OCaml and any OCaml tools and libraries. This blog post shows us how to set-up opam to install the OCaml compiler and development tools to support your workflow.

Working with Windows

The OCaml tools are typically well supported on Linux, with macOS ports available of most binaries. If you are on a Windows, the best supported environment is the Windows Subsystem for Linux.

The OCaml Compiler Pipeline

Fri, 01 May 2020 11:13:12 -0600

I was first introduced to ML through the Coursera Programming Languages course. After the initial learning curve, I was impressed by the power of the type system and the flexibility of pattern matching. I’ve been wanting to resume my education in functional programming, and am picking up OCaml for a personal project I’m working on. Diving into the OCaml ecoystem, I was drawn to Reason, a new syntax for OCaml, and BuckleScript a compiler that integrates OCaml with the JavaScript ecosystem. The relationship between Reason, BuckleScript, and OCaml can difficult to understand, leading to this blog post about the OCaml compiler pipeline that highlights the intersection between OCaml and BuckleScript.

Above-the-line and below-the-line

Wed, 22 Apr 2020 05:48:21 -0600

Engineering, for much of the twentieth century, was mainly about artifacts and inventions. Now, it’s increasingly about complex systems. As the airplane taxis to the gate, you access the Internet and check email with your PDA, linking the communication and transportation systems. At home, you recharge your plug-in hybrid vehicle, linking transportation to the electricity grid. At work, you develop code, commit it to a repository, run test cases, deploy to production, and monitor the result. Today’s large-scale, highly complex systems converge, interact, and depend on each other in ways engineers of old could barely have imagined. As scale, scope, and complexity increase, engineers consider technical and social issues together in a highly integrated way as they design flexible, adaptable, robust systems that can be easily modified and reconfigured to satisfy changing requirements and new technological opportunities.

How Does DNS Work?

Thu, 16 Apr 2020 05:59:12 +0000

Before the Internet became a global network connecting millions of devices, it was a simple research experiment connecting a handful of institutions. In the beginning, the number of unique internet addresses could be measured in the tens. As the network expanded that number quickly grew into the hundreds and thousands and it became difficult to remember and type in IP addresses for each of these hosts.

To manage the growing number of network hosts, a simple text file, called HOSTS.txt recorded each host and their IP address. To add your name to the hosts file, you needed to send an e-mail describing the changes you wanted to apply. The authority for the HOSTS.txt file would apply these changes once or twice a week and anyone who wanted to grab the updated list would periodically FTP to the canonical source, grab the latest file, and update their own list of hosts. Naturally, as this small network expanded into, and was eventually replaced by, the Internet, this solution became untenable – there were just too many hosts to keep track of, keep consistent, and to serve from a single canonical file using FTP and manual updates. HOSTS.txt did not scale.

Building Learning Communities

Tue, 24 Mar 2020 11:59:15 +0000

Leading software companies have discovered that developing capable technology is not enough to guarantee long-term success. To stay relevant, software leaders need to develop and support the repeatable systems necessary to develop and sustain knowledge and expertise. Many organizations have taken inspiration from Spotify’s culture and adopted the concept of a guild or community of practice to connect engineers throughout the organization and steer them towards common goals. As organizations adopt this model, what is often missing is a clear understanding of the purpose of communities of practice and a repeatable process for developing the communities to their fullest potential. This post provides some guidance based on our experience developing a community of practice at Workiva, it also includes some best practices from the book Cultivating Communities of Practice.

Optimizing Processes Using a Design Structure Matrix

Thu, 27 Feb 2020 05:48:21 -0600

Complex processes may require collaboration and coordination of many components. We can model such processes using a Design Structure Matrix to represent information flow among the components, and then optimize the process to avoid rework and downtime.

As a simplified example, consider a project with only two tasks: “A” and “B”, and a directed graph representing this system where a vertex represents a task and an edge represents the flow of information between tasks. Depending on the process being modeled, these two vertices can be arranged in one of three different configurations.

Interdependence and Self-Reliance

Mon, 27 Jan 2020 09:40:16 +0000

After graduating from university my (future) wife and I travelled and worked in Kenya as part of the Commonwealth of Learning — an intergovernmental agency dedicated to open learning and distance education. As fortune would have it, my brother had an internship in the neighbouring country of Tanzania during the same time period, and we were able to meet for a few days to enjoy the East African coast in the city of Mombasa.

Improving Software Architecture Using a Design Structure Matrix

Mon, 20 Jan 2020 05:48:21 -0600

To meet the challenges of scaling systems in size, scope, and complexity, it is useful to look at new approaches and theories to analyze, design, deploy, and manage these systems. A Design Structure Matrix (DSM) is an approach that supports the management of complexity by focusing attention on the elements of complex systems and how they relate to each other. DSM‐based techniques have proven to be very valuable in understanding, designing, and optimizing product, organization, and process architectures. This article explores in more depth how we can use the techniques developed by the design structure matrix community to improve software architecture.

Using Little’s Law to Measure System Performance

Fri, 29 Nov 2019 14:03:15 +0000

A queueing system can be described as the flow of items through a queue. In a queueing system, items arrive at some rate to the system and join one or more queues inside the system. These items receive some kind of service, and when the work is done, they depart the system.

A simple queueing system

Little’s Law is a pretty simple model of queueing systems.

$$ L=\lambda W $$

Little’s Law says that the average number of items in a queueing system, denoted $L$, equals the average arrival rate of items in the system, $\lambda$, multiplied by the average waiting time of an item in the system, $W$.

Why I’m not (too) worried about Python 2

Mon, 25 Nov 2019 09:53:12 -0600

Python 2 will retire in about one month. Given many organizations continued reliance on it, you may be asking “Now What?” What does this change mean for a company that heavily relies on a deprecated language?

Many times, the Python 2 deployed in an organization still generates a lot of value. Yet as this code continues to age, you expose ourselves to potential security vulnerabilities with fewer avenues to address them. To continue running Python 2 and safely address this challenge, you have three options:

Riding the Architecture Elevator

Tue, 01 Oct 2019 19:40:15 +0000

Large organizations have a lot of layers. From the C-Suite that is concerned about strategy and vision, to middle management who are executing on projects and programs, down to individual contributors working on project features. These layers provide a number of advantages, all derived from being able to better manage complexity. For example, layers provide a nice separation of concerns: as a software engineer, I don’t have to worry about tax codes and payroll because the finance department can take care of this. As an intern, I don’t need to worry about the global marketing strategy, I can just take care of implementing the widgets we need delivered to customers.

How Does WebRTC Work?

Tue, 17 Sep 2019 06:47:51 +0000

To deliver real-time communication (RTC) from browser to browser requires a lot of technologies that work well together: audio and video processing, application and networking APIs, and additional network protocols that for real-time streaming. The end result is WebRTC — over a dozen different standards for the application protocols and browser APIs that enable real-time communication for the web.

How Does LTE Work?

Tue, 30 Jul 2019 09:01:52 +0000

There is no one-size-fits-all cellular network used across the world, and trying to understand how cellular technology works across all the different uses cases is difficult, if not impossible, in a short blog post. So, rather than trying to understand every possible standard, this article will focus solely on LTE networks. Fortunately, competing standards and implementations are roughly similar and we can extrapolate any lessons learned about LTE to other cellular networks without much difficulty.

How Does WiFi Work?

Wed, 10 Jul 2019 06:54:45 +0000

WiFi, technically specified in the IEEE 802.11 set of standards, is one of the most widely deployed wireless standards in the world. Chance are the device you are using to read this article has is WiFi enabled. WiFi is a straightforward extension of Ethernet, with some slight adaptations for using radio instead of copper wire as the communication channel.

Like Ethernet, WiFi has no central process that controls which device is allowed to transmit data at any point in time. Instead, each device decides on its own, and all devices must work together to guarantee good shared channel performance. With Ethernet, the protocol senses when the communication channel is busy and waits until it is free before sending data (carrier sensing). Ethernet also adds a collision detection protocol as an optimization. If a collision is detected, nodes stop sending data and use a randomized backoff algorithm to decide when to begin sending again. Together, these algorithms form the carrier-sense multiple access with collision detection algorithm (CSMA/CD). WiFi uses a similar strategy to Ethernet, but is restricted by the communication channel — there is no reliable way to detect collisions using radio waves. Therefore, instead of collision detection, WiFi uses a collision avoidance strategy defined by the carrier-sense multiple access with collision avoidance algorithm (CSMA/CA).

How Does Ethernet Work?

Mon, 08 Jul 2019 05:59:12 +0000

Ethernet is a technology developed a Xerox PARC in 1973 and 1974 to support local area networking. It has since been expanded to include a whole family of technologies that support various network architectures and topologies as part of the IEEE 802.3 working group dedicated to supporting networking using physical connections and devices (i.e. not wireless).

Ethernet was built with the assumption that all computers on a network use a shared communication channel. The primary problem with using a shared connection is creating a sense of orderly traffic when an entire network of computers wants to constantly transmit data over the same channel. The core of that solution is sensing other node’s activity and waiting until the line is free and using collision detection to minimize the amount of traffic on the network.

Wireless Networks and Shannon’s Law

Fri, 05 Jul 2019 06:32:12 +0000

All wireless networks (Wi-Fi, Bluetooth, 3G, LTE, etc.) operate using radio signals. Because they operate over the radio, all communication methods have a maximum channel capacity, regardless of technology. This maximum capacity was which is determined by the same underlying principles of information theory developed by Claude Shannon during World War II, known as Shannon-Hartley theorem or Shannon’s Law. Shannon’s Law states that This capacity relationship can be stated as:

$$ {C=W\log _{2}\left( 1+{S \over N} \right)} $$

Curate Don’t Dictate

Mon, 24 Jun 2019 06:03:53 +0000

Inspiration for software architecture often comes from the world of building architecture. In building architecture, the architect takes in local building codes to understand construction requirements. They analyze various building components like ductwork and furnaces, windows and doors, and figure out where and when to use standard components and when to build custom. They provide cost estimates for each of the components and for the whole, and then build out a blueprint providing upfront design and specification.

Tied to Machines Podcast — Architecture

Thu, 20 Jun 2019 10:04:38 +0000

I recently had the pleasure of being part of the Tied to Machines podcast. We talked about the role of architecture, architectural leadership, and the intersection between architecture and business.

You can listen to the full episode here.

Principles of Architectural Leadership

Thu, 06 Jun 2019 07:55:23 +0000

Software is core to the operation of our business, and as architects, we are the key conduit between business and technology. Being technical leaders within this intertwined relationship means that we have a responsiblity to make sure that our business decisions and our technology decisions stay aligned. Being in this position demands leadership skills that are equal or better than our technical skills, so that we can effectively align business strategy with technical strategy, communicate that strategy to teams, motivate both teams and individuals, and influence outcomes.

How Does UDP Work?

Wed, 29 May 2019 06:47:51 +0000

The User Datagram Protocol (UDP), first described in 1980 by RFC 768, offers a minimal set of functionality: there is no guarantee of message delivery, no guarantee of message order, no congestion avoidance, and no tracking of connection state. In fact, UDP is often referred to as the null protocol, because it offers little functionality not already included in the IP layer.

Innovation with Constraints

Fri, 17 May 2019 14:07:51 +0000

One of the many paradoxes of human creativity is that it seems to benefit from constraints. Although we [perceive] the imagination as requiring total freedom, the reality of the creative process is that it’s often entangled with strict conventions and formal requirements. Pop songs have choruses and refrains; symphonies have four movements; plays have five acts; painters still rely on the tropes of portraiture.

Jonah Lehrer

Constraints can seem like the last thing you’d want for a creative project, but they’re actually beneficial when it comes to doing good work. Anyone who has written knows the hurdle of the blank page, and the feeling that comes from being paralysed by innumerable choices. By restricting the choices available to us, paralysis disappears and we can focus on the task at hand. Don’t believe me? Consider the task of writing an entire story in less than six words. It seems impossible! How can you develop characters, expand a plot, and tell a tale in six words? Here’s how Hemingway did it:

How Does TCP Work?

Wed, 15 May 2019 10:21:51 +0000

The transmission control protocol (TCP) does one job very well — it creates an abstraction that makes an unreliable channel look like a reliable network. For applications built over an unreliable network like the Internet, TCP is a godsend that hides a lot of the inherent complexity in building networked applications. A laundry list of TCP features that application developers rely on every day includes: retransmission of lost data, in-order data delivery, data integrity, and congestion control. This article provides an introduction TCP, describing the structure of TCP segments, how TCP connections are established, and the algorithms that govern the flow of data between senders and receivers.

How Do Websockets Work?

Thu, 04 Apr 2019 13:40:15 +0000

A WebSocket is a persistent connection between a client and server. WebSockets provide a bidirectional, full-duplex communications channel that operates over HTTP through a single TCP/IP socket connection. At its core, the WebSocket protocol facilitates message passing between a client and server. This article provides an introduction to the WebSocket protocol, including what problem WebSockets solve, and an overview of how WebSockets are described at the protocol level.

The Zero Bug Policy

Wed, 03 Apr 2019 06:44:16 +0000

A few years ago, a company I worked for was suffering from quality problems. We were expanding into new areas, pushing the product in new directions, and releasing new features quickly. As we pushed out new and evolved products, quality declined. Everything came to a head when customers began openly complaining about software quality. Our CTO stepped in with a mandate to solve the quality problem. His approach? The Zero Bug Policy — no-one was allowed to work on new features until the number of bugs in the product backlog was zero.

How Does HTTP/2 Work?

Mon, 01 Apr 2019 11:13:38 +0000

Note: To make this easier to read (and write), h1 may be used in place of HTTP/1, and h2 may used in place of HTTP/2.

HTTP/1 has a long and storied history. Originally developed as a sixty page specification documented in RFC 1945, it was designed to handle text-based pages that leverage hypermedia to connect documents to each other. Typical web pages would kilobytes of data. For example, the first web page was a simple text file with web links to other text documents. Now, the web is made up of media-rich sites containing images, scripts, stylesheets, fonts, and more. The size of a typical web page is measured in megabytes rather than kilobytes, and the number of requests required to assemble a full page can be over one hundred. The reality of how web pages are built today does not match the reality that HTTP/1 was designed to support.

Vendor Management is a Core Competency

Thu, 21 Mar 2019 09:40:15 +0000

Building and running a successful company requires an immense amount of work and talent. It also requires focus. Companies cannot try and solve problems with new and innovative techniques everywhere they operate. It is important to understand the areas your company should innovate in, and outside of that scope, use existing standards and off-the-shelf software as much as possible. There is only so much innovation that a company (or the market) is willing to bear and walking that line is a key factor in developing a successful product on time and budget.

Overambitious API gateways

Fri, 22 Feb 2019 09:21:53 +0000

In a microservices architecture, an API gateway can help address a number of challenges: providing a stable endpoint for clients to call, allowing an easy process for releasing new endpoints, or handling SSL termination on behalf of services, to name a few. So how do we decide what features of an API gateway to adopt, and which to leave behind? This article highlights the key functions that an API gateway can provide, suggests the scope of problem that API gateways are well-suited to solve, and cautions against the features that make API gateways too ambitious.

Putting the R in D

Mon, 28 Jan 2019 19:40:15 +0000

The Research and Development department would appear to give equal weight to both research and development by virtue of naming, yet there are few engineers who would claim that research is a primary responsibility of their job. Between working on product features, planning sprints, fixing bugs, and attending meetings there is little time left for research. But what is the cost of foregoing research in favour of development? In this article, I consider the economic cost of ignoring research and argue that focusing solely on development is harmful to both product and engineering.

Fault-Tolerance and Data Consistency Using Distributed Sagas

Thu, 06 Dec 2018 14:55:15 +0000

While microservices have become the defacto architectural pattern for building modern systems, they come with their own set of challenges. Key among them is ensuring application data consistency when data is spread over multiple databases. This article discusses one solution to this problem, distributed sagas. Distributed sagas provide consistency guarantees for systems spanning multiple databases in the face of failure using a clear and manageable implementation pattern. A saga is highly related to a finite state machines that moves consistently through a set of states, ensuring at each step that some conditions hold.

IaaS, PaaS, SaaS and Infrastructure

Tue, 23 Oct 2018 15:03:32 +0000

Infrastructure is undergoing a significant paradigm shift. At my first job as a software developer, scaling our infrastructure meant buying a physical machine and installing it in a rack, setting up the system images and base software by hand, configuring the network using some shell scripts, and finally, making it available for developers to install software. Now, with the advent of cloud computing, the same capabilities — installing and running software — are available on-demand.

Alpha Conversion

Thu, 18 Oct 2018 09:16:45 -0600

Alpha conversion (also written $\alpha$-conversion) is a way of removing name clashes in expressions.

A name clash arises when a $\beta$-reduction places an expression with a free variable in the scope of a bound variable with the same name as the free variable.

— Greg Michaelson, An Introduction to Functional Programming Through Lambda Calculus

When we are performing a $beta$-reduction it is possible that the variable name in an inner expression is the same as a variable name in an outer expression. For example, consider

Beta Reduction

Thu, 04 Oct 2018 09:16:45 -0600

Formally, beta reduction (also written $\beta$-reduction) is the replacement of a bound variable in a function body with a function argument. The purpose of $\beta$-reduction is to compute the result of a function by function application using specific rules.

More formally, the beta reduction rule states that a function application of the form $(\lambda x.t)s$ reduces to the term $t[x := s]$. The term $t[x := s]$ means that all instances of $x$ in $t$ are replaced with $s$. The $\rightarrow$ syntax is used as a shorthand for beta reduction. We can specify beta-reduction explicitly using the notation $(\lambda x.t)s \rightarrow t[x := s]$, which means that the beta reduction of $(\lambda x.t)s)$ is $t[x := s]$. The beta reduction removes the $\lambda$ symbol and resolves to the function’s body with the argument $s$ substituted into the body.

Building Stateful Services with Kubernetes

Tue, 02 Oct 2018 10:38:23 -0600

The Kubernetes sweet-spot is running stateless microservices that can scale horizontally. By keeping state out of your application, Kubernetes can seamlessly add, remove, or restart pods to keep your service healthy and scalable. Developing a stateless application is, without question, the easiest way to ensure that your app can scale with Kubernetes. However, there are some workloads that do not run effectively in a stateless way, and for that, Kubernetes offers a few tools for developing stateful applications: leader election, StatefulSets and session affinity.

Eta Reduction

Thu, 27 Sep 2018 10:16:45 -0600

The purpose of eta reduction (also written $\eta$-reduction) is to drop an abstraction over a function to simplify it. This is possible when there is nothing more that a function can do to its argument. For example, imagine that we have a simple function $ f\ x = g\ x $. Both $g$ and $f$ take the same argument, $x$, and the function application function results in the same value (specified by the equality symbol). Since both $f$ and $g$ take the same argument and produce the same result, we can simplify the equation to just $f = g$. In lambda calculus, this simplification is called $\eta$-reduction.

Testing in Production — Building Observable Distributed Systems

Tue, 25 Sep 2018 09:40:15 +0000

Complex systems exhibit unexpected behavior.

— John Gall, The Systems Bible

One reaction to the myriad failure cases we encounter with distributed systems is to add more testing. Unfortunately, testing is a best-effort verification of system correctness — we simply cannot predict the failure cases that will happen in production. What’s more, any environment that we use to verify system behaviour is — at best — a pale imitation of our production environment. An alternative to adding more tests is to add more monitoring and alerting so we know as soon as possible that a system shows signs of degradation. Unfortunately, monitoring and alerting suffers from the same faults as testing — we monitor for behaviour that is predictable in nature or that we have experienced in the past. Together, monitoring and testing try to enumerate all possible permutations of partial and total system failure. Unfortunately, they only provide a simulation of how you expect a system to actually function in production.

Normal, Applicative and Lazy Evaluation

Tue, 18 Sep 2018 10:26:45 -0600

A lambda expression is said to be in normal form if it cannot be reduced any further, meaning that the expression no longer contains any function applications. More formally, a reducible expression is called a redex, and a lambda expression is in normal form when it contains no more redexes.

Redex: A reducible function expression.
Normal Form: A lambda expression that contains no redexes.

Given a lambda expression, there are two primary strategies for reducing it to normal form: normal-order evaluation, or applicative-order evaluation. This article discusses both methods, their pros and cons, and an alternative evaluation strategy that combines the pros from both — lazy evaluation.

Representing Pairs and Lists in Lambda Calculus

Fri, 07 Sep 2018 09:20:45 -0600

Having covered types, let’s now turn our attention to lists. Lists are general purpose data structures for storing sequences of items. In lambda calculus, lists are represented using pairs, with the first item of the pair representing the head of the list, and the second item representing the rest of the list. A special value, nil, at as the second item of the pair terminates the list.

Pairs

Let’s start by focusing on pairs (or tuples). A pair is built from two arguments, $a$ and $b$, and returns a function $f$ enclosing those two arguments:

Typed Lambda Calculus

Tue, 21 Aug 2018 09:26:45 -0600

Lambda calculus is a very simple language. If you take away any syntactic sugar, all you are left with is functions that take arguments and return results. You can use these simple building blocks to construct functions that represent numbers and arithmetic, but there is no way to restrict, for example, arithmetic functions to require numeric operands. This is where types come in. Generally speaking, types allow you to control the use of functions so that only meaningful combinations of inputs and outputs are used.

A Guide to the Kubernetes Networking Model

Wed, 11 Jul 2018 13:27:31 -0600

Kubernetes was built to run distributed systems over a cluster of machines. The very nature of distributed systems makes networking a central and necessary component of Kubernetes deployment, and understanding the Kubernetes networking model will allow you to correctly run, monitor and troubleshoot your applications running on Kubernetes.

Networking is a vast space with a lot of mature technologies. For people unfamiliar with the landscape, this can be uncomfortable because most people have existing preconceived notions about networking, and there are a lot of both new and old concepts to understand and fit together into a coherent whole. A non-exhaustive list might include technologies like network namespaces, virtual interfaces, IP forwarding, and network address translation. This guide intends to demystify Kubernetes networking by discussing each of Kubernetes dependent technologies along with descriptions on how those technologies are used to enable the Kubernetes networking model.

Infrastructure in an Age of Commodities

Tue, 19 Jun 2018 15:53:15 +0000

Early computers were described using mathematical notation and theoretical constructions, which were then translated by enterprising machinists into custom built calculation engines. The first computer programmers using these machines built applications directly in hardware by plugging together wires and sockets in varying configurations. Even with these short-comings, the value of general purpose computing machines was evident. As companies began to realize the utility of computing, they saw computing as a means for differentiating themselves from their competitors.

Recursive Lambda Functions the Y-Combinator

Mon, 11 Jun 2018 11:38:45 -0600

In a purely functional language — like lambda calculus — programs are expressed as nested function calls. Repetition in such an environment requires that nesting of function calls continues until some condition is met. During the repetition, each function passes its result to the next function in the nested chain and this repetition is completed when a test for some condition passes. The repetitive behaviour I’ve just described is recursion:

Simplifying Lambda Syntax

Fri, 25 May 2018 09:26:45 -0600

Evaluating lambda functions requires using lots of brackets, which can be tedious and are a major source of error for evaluating expressions by hand. To simplify expressions, you can omit brackets when it is clear what the intention of the function is. Particularly, a function application can omit the brackets surrounding each individual parameter and assume the function is applied to the nearest argument. So, instead of expressing a function of three arguments as

Introducing Lambda Calculus

Fri, 27 Apr 2018 09:26:45 -0600

Lambda calculus provides some of the foundational structures that functional programming is built from. It therefore seems fitting to start my journey through functional programming with a thorough examination of lambda calculus. This first post will introduce Lambda calculus with references to the book An Introduction to Functional Programming Through Lambda Calculus.

Syntax

The complete syntax for Lambda calculus is surprisingly small and comprehensible. This section lists the syntax in its entirety, while following sections break the syntax down to explain each part.

A Principled Approach to Architecture

Fri, 23 Mar 2018 14:39:15 +0000

A principle is a concept or value that is a guide for behaviour or evaluation.

— Wikipedia

This post presents a principled approach to architecture. These principles specify what I believe is important about architecture, without diving into any details about how an architect should work. No matter how an architect works day-to-day, by following principles, you can be sure you are providing value in the right areas.

As usual, this post is personal opinion, and I’m interested in hearing any differing or similar opinions in the comments.

Range, Domain, and Codomain

Fri, 09 Mar 2018 10:26:45 -0600

Three common terms come up whenever we talk about functions: domain, range, and codomain. This post clarifies what each of those terms mean.

Before we start talking about domain and range, lets quickly recap what a function is:

A function relates each element of a set with exactly one element of another set (possibly the same set).

Math is Fun

That is, a function relates an input to an output. But, not all input values have to work, and not all output values. For example, you can imagine a function that only works for positive numbers, or a function that only returns natural numbers. To more clearly specify the types and values of a functions input and output, we use the terms domain, range, and codomain.

Functional Microservices

Mon, 05 Mar 2018 09:08:15 +0000

One proposed benefit of following a microservice architecture is that each service can be developed, released, and supported independently. In theory this allows development teams to work with less coordination and less overhead, leading to faster development times. In practice, this is difficult to achieve without some guidelines that make it work.

The book The Tao of Microservices provides two such guidelines — transport independence, and pattern matching — that create an environment allowing you to compose services. Service composition is the holy grail of microservices, allowing you to build progressively more complex functionality safely and efficiently. This post discusses how transport independence and pattern matching allow you to compose services, what service composition means in terms of functions, and how you can use this composition to build complex services additively.

A Functional Programming Learning Plan

Fri, 09 Feb 2018 10:26:45 -0600

I’m documenting my journey from functional neophyte to (hopefully) functional programmer by writing a series of blog posts on the topic. So far I’ve covered what functional programming is and why you would want to learn about it. In this post, I’m going to describe the resources I will be using to become functionally fluent.

Although I have previously said I’m learning about functional programming, I should be more specific. I do already have some middling experience with Clojure and Lisp, but I have too many battle scars from running dynamic languages in production to go down that path again. At this point in my career, my experience dictates that any new code I write will be statically typed. Because of this bias, I’m going to approach learning functional programming through the lens of statically typed functional languages. My learning plan will reflect that and help narrow the scope of this project.

Practical Differences Between Functional and Imperative Programming

Fri, 02 Feb 2018 10:26:45 -0600

I previously talked about what functional programming is by comparing it to other programming paradigms. This post expands on that post to talk specifically about practical differences between functional programming and the paradigm most of us are intimately familiar with — imperative. This post is punctuated with some quotes from the book An Introduction to Functional Programming Through Lambda Calculus.

It’s worth noting that each of these practical differences are enabled because of the power of referential transparency.

Why Functional Programming? The Benefits of Referential Transparency

Fri, 02 Feb 2018 10:26:45 -0600

Having covered what functional programming is, I wanted to spend a minute or two discussing why I want to learn functional programming in the first place. I’m sure we have all heard vague things about “side-effects”, “immutability”, and “composition”, but I wanted to dive a bit deeper on the topic to describe what — to me — is important about functional programming.

Referential Transparency

The key differentiating feature of (pure) functional programs is that they provide referential transparency. An expression is said to be referentially transparent if it can be replaced with its corresponding value without changing the program’s behaviour.

Overcoming Optimism with a Premortem

Wed, 24 Jan 2018 10:03:45 -0600

I’ve been reading the excellent book Thinking, Fast and Slow by Daniel Kahneman and came across a strategy for dealing with a common human behaviour problem that has direct impact on software development: overconfidence.

According to Kahneman’s research,

“overconfidence is a direct consequence of [how we think] that can be tamed — but not vanquished.”

In other words, our brains are wired to make overconfident predictions and forecasts. In software development, this overconfidence usually presents itself in estimates of the importance of projects to the business, the success rate of new projects, and in development timelines. We all seem to have an intuition that these biases exist, but what can we do to counteract them? One idea presented by Kahneman’s colleague Gary Klein is the premortem.

What is Functional Programming?

Tue, 23 Jan 2018 10:26:45 -0600

I’m documenting my journey from functional neophyte to (hopefully) functional programmer by writing a series of blog posts on the topic. This is the first post describing what, exactly, the word functional programming means.

Functional programming is a programming paradigm that lives alongside other programming paradigms. None of these paradigms have a precise, unanimous definition or standard, and there is not real agreement on which paradigm is better or worse for building particular types of software.

Cloze Deletions

Mon, 08 Jan 2018 05:41:48 +0000

This page provides a collection of premade Anki decks filled with cloze deletion tests for learning a second language. Use the table below to find the dataset for the language you speak (the native language), and the language you wish to learn (the target language).

Native Language	Target Language	Anki Package	Audio	CSV
English	French	eng_fra.apkg	eng_fra.zip	eng_fra.csv
English	German	eng_deu.apkg	eng_deu.zip	eng_deu.csv
English	Spanish	eng_spa.apkg	eng_spa.zip	eng_spa.csv
English	Italian	eng_ita.apkg	eng_ita.zip	eng_ita.csv

Frequently Asked Questions

How to Import these Decks into Anki

You can import the cloze deletions into Anki using the CSV file provided for each language. To import a file, click the File menu and then select Import.

Improving Test Coverage Using Exploratory Outcomes

Fri, 22 Dec 2017 08:12:12 -0600

In general, developers test features by focusing on the positive outcomes — the so-called “happy paths”. Unfortunately, this optimism can blind us to the less obvious or less probable outcomes that can cripple an application. I found one way to counteract this tendency is to try and “go beyond the happy path” by exploring the outcome of unhappy paths through a feature. I came across this idea in the excellent book Fifty Quick Ideas to Improve Your Tests by Gojko Adzic, David Evans, and Tom Roden, and expanded upon the book Writing Great Specifications by Kamil Nicieja.

Bulk Generating Cloze Deletions for Learning a Language with Anki

Wed, 20 Dec 2017 11:14:31 -0600

tldr; Looking to learn a language using cloze deletions and Anki? Click here.

One challenge in learning a second language is the sheer amount of vocabulary required for fluency. For example, one study has shown that the average eight year old knows 8000 words, while the average adult might know somewhere between 20,000 and 35,000 words. University graduates might know upwards of 50,000 words depending on their specialization.

As an adult learning a second language, exposure to a lot of different words in their context is one of the best ways to learn vocabulary. A common test for learning words in context is called a cloze test.

Building Empathic Software Using Specification by Example

Fri, 15 Dec 2017 14:55:15 +0000

In most organizations, software development is split between two groups — product management and engineering. Product management is focused on building the right system. This requires product managers to meet with users, try and understand their needs, and develop solutions that meet those needs. To actually develop the solution, product managers must involve engineers who are focused on building the system right — writing the code, making it stable, and supporting it in production. Unfortunately, there exists an uncomfortable gap between product managers and engineers that forces the product manager to explain features in terms that an engineer can implement, and that forces the engineers to explain technological constraints to product managers in terms that a product manager can understand. To bridge this gap requires careful and considerate communication. It requires empathy from both product managers and engineers.

How Fast Does it Need to be Anyways? The QUPER Model of Analyzing Non-Functional Requirements

Thu, 23 Nov 2017 13:32:15 +0000

We all know that a page that loads in three seconds will provide a negative user experience. But does having every page load in less than one second make a meaningful difference? How can you tell? When is enough … enough? Non-functional requirements such as performance are often not precise enough to be specified as discrete numbers. Rather, they work on a sliding scale of acceptability.

Would slightly better performance be significantly more valuable from a market perspective? Would significantly better performance be just slightly more expensive to implement? When dealing with performance, usability, reliability and so forth, we often end up in a difficult trade-off analysis.

What is CQRS?

Tue, 08 Aug 2017 19:40:16 +0000

Bertrand Meyer first introduces the principle of Command Query Separation in his book Object-Oriented Software Construction. The principle states that a well designed object should have methods that are either commands or queries. A command changes the state of an object, but does not return any data, while a query returns data and does not change any state. By dividing methods into these two categories, you will have a better understanding of what does, and what does not, change the state of your system.

Dissecting SQS FIFO Queues — Does Ordered and Exactly Once Messaging Really Exist?

Tue, 01 Aug 2017 09:41:15 +0000

At first glance, Amazon’s First-In-First-Out (FIFO) message queues provide an excellent feature set for business-critical scenarios. With FIFO, the order in which messages are sent and received is strictly preserved. With exactly-once processing, message duplicates are not introduced into the queue, and consumers control when a message is made available for redelivery. Reading past the marketing hype, how well do FIFO queues work in the real world?

This article takes a deep dive into SQS FIFO queues to test the claims of message ordering and exactly-once processing, paying particular care to the conditions under which these claims hold. I show how exactly-once processing can be achieved, and how that message ordering is preserved through failure conditions. I conclude with an examination of the relationship between in-order and exactly-once processing and atomic broadcast and consensus.

Learning a Language with Amazon Polly and a Serverless Chalice App

Fri, 28 Jul 2017 11:59:15 +0000

For the past year I’ve been making a concerted effort to learn French using the methods from the book Fluent Forever, which is an excellent resource for learning how to learn a language. For those not familiar with the method, it boils down to this:

Learn Pronunciation: knowing how to correctly pronounce words in your target language makes everything else easier.
Learn Frequently Used Words: not all words are created equal, learn the most frequently used words first.
Learn Grammar: put together grammatical sentences using the words you already know.

If you turn your head to the side and squint at that list, it somewhat resembles the steps you would take to learn a language as an infant — first understand the sounds of the language, then learn words (“mommy”, “daddy”), and finally put together correct sentences. In addition, as an infant you have a constant source of high quality input helping you learn words and grammar. You can imagine the following “conversation” between an adult and a hungry child:

Evolving Messaging For Microservices: A Retrospective from Building Workiva’s Messaging Platform

Wed, 28 Jun 2017 18:29:21 +0000

Workiva’s original product — supporting the mundane task of filing documents with the SEC — was so innovative that within its first 5 years it was being used by more than 65 percent of the Fortune 500 and generating more than $100 million in annual revenue. During that explosion in growth, the software development team focused solely on supporting and expanding the existing software stack. However, after several years of growth and expansion maintaining and extending that single code base became unsustainable.

How to create a functional VPC using CloudFormation

Wed, 07 Jun 2017 20:59:15 +0000

This tutorial walks through how to create a fully functional Virtual Private Cloud in AWS using CloudFormation. At the end of the tutorial, you will have a reproducible way to create a virtual cloud with three subnets, a security group, and an internet gateway with SSH access for your IP address. I’ve found this template useful for creating an isolated environment to develop and test software.

Full code for this tutorial is available on Github.

Compiling private Java code from Leiningen

Wed, 31 May 2017 11:15:08 +0000

For a recent project, I wanted to verify the correctness of a distributed queue implementation based on Amazon SQS. For this, I turned to the Jepsen library for verifying distributed systems. Jepsen is written in Clojure and the first task was to get Jepsen to compile with a Java library hosted on our internal Maven repository. I googled for a while, asked around, and assembled instructions from a few different places. Here then, is a single blog post summarizing the solution for future use.

Uploading Large Payloads through API Gateway

Wed, 10 May 2017 16:12:14 +0000

API Gateway supports a reasonable payload size limit of 10MB. One way to work within this limit, but still offer a means of importing large datasets to your backend, is to allow uploads through S3. This article shows how to use AWS Lambda to expose an S3 signed URL in response to an API Gateway request. Effectively, this allows you to expose a mechanism allowing users to securely upload data directly to S3, triggered by the API Gateway.

Getting Started With TLA+

Thu, 20 Apr 2017 11:00:23 -0600

This post shows how to write your first simple TLA+ specification.

What is a specification?

In software, the behaviour of a system is described as a sequence of states. Mathematically, each state is expressed as a function F(t), which represents the state of a system at time t. To completely specify a system, we write out each state to fully define the systems behaviour.

A simple clock

This example comes from Chapter 2 of the book Specifying Systems by the creator of TLA+, Leslie Lamport. If you are unfamiliar with the math used here, refer to basic math for writing TLA+ article.

Basic Math for TLA+

Wed, 19 Apr 2017 11:00:23 -0600

At its most basic, TLA+ is a written description of what a system is supposed to do. More specifically, TLA+ is a specification language for formally defining the behavioural properties of a system.

TLA+ is based on temporal logic, which is built on top of first-order logic and set theory, and provides some conveniences for working with large specifications for complex systems. You can think of a TLA+ specification as mostly ordinary math and logic, glued together with temporal logic for parts requiring it.

First Musings on TLA+

Tue, 18 Apr 2017 11:00:23 -0600

I’ve been helping define some concurrent algorithms and I’m struggling with a number of issues: concurrent algorithms are difficult to design, they are often difficult to implement, and, even after they are designed, are difficult to guarantee that they are correct. This lead me into some research on formal specifications for algorithms, and how they can help. Finally, I settled on TLA+ as a viable tool for just such a problem.

Paper Review: WebTables: Exploring the Power of Tables on the Web

Wed, 29 Mar 2017 09:34:37 -0600

Title and Author of Paper

WebTables: Exploring the Power of Tables on the Web. M.J. Cafarella et al.

Summary

WebTables is a project to extract and process HTML tables from Google’s serach index. It attempts to answer two questions: what are some effective techniques for searching structured data at search engine scale, and what can be derived from analyzing a large corpus of HTML tables?

Web documents often contain structured and relational data embedded in HTML tables. The WebTables project extracted 14.1 billion English language HTML tables and further filtered those down to 154 million tables that contain structured data. From this data, we have the potential to determine semantic information embedded in the web, create visualizations, and integrate web documents into new applications.

Paper Review: Combining Systems and Databases: A Search Engine Retrospective

Mon, 27 Mar 2017 06:00:31 -0600

Title and Author of Paper

Combining Systems and Databases: A Search Engine Retrospective. Eric A. Brewer.

Summary

Search engines manage data and respond to queries, which provides some similarities to databases. However, search engines are really an application-specific system built to handle large datasets. This system can leverage databases, or not, depending on the system goals. This paper describes a search engine design that leverages the ideas and vocabulary of the database community.

Publish-Subscribe Messaging Using Amazon SQS

Fri, 24 Mar 2017 18:29:21 +0000

Amazon’s Simple Queue Service (SQS) provides durable messaging guarantees and is an excellent backbone for messaging services. However, SQS does not support “fan-out” of messages so that multiple consuming services can each receive a copy of a message. This means that true publish-subscribe messaging requires some additional work. This post describes some architectural choices that provide durable publish-subscribe messaging using SQS by tracking messaging subscribers using a database, and matching published messages to interested subscribers.

Paper Review: The Anatomy of a Large-Scale Hypertextual Web Search Engine

Thu, 23 Mar 2017 06:07:31 -0600

Title and Author of Paper

The Anatomy of a Large-Scale Hypertextual Web Search Engine. Sergey Brin and Lawrence Page.

Summary

This paper describes the underpinnings of the Google search engine. The paper presents the initial Google prototype and describes the challenges in scaling search engine technology to handle large datasets. At the time of writing, the main goal of Google is to improve the quality of web searches by taking advantage of the existing link data embedded in web pages to calculate the quality of a page.

Paper Review: Consistency Analysis in Bloom: a CALM and Collected Approach

Wed, 22 Mar 2017 06:07:31 -0600

Title and Author of Paper

Consistency Analysis in Bloom: a CALM and Collected Approach. Alvaro et al.

Summary

Distributed programming is difficult for even experienced developers to get correct. Understanding the tradeoff between consistency, availability, and latency, while guaranteeing data correctness, provides a wealth of problems for the application developer. This paper presents a language and method for programmatically verifying distributed consistency.

CALM - Consistency and Logical Monotonicity

There is a connection between distributed consistency algorithms and logical monotonicity, that is, our programs must be correct even in the face of the delay and re-ordering of messages and data across different nodes in a system. By designing programs with order independence, we can ensure that the logic of the system is maintained within a distributed environment.

SQS or Kinesis? Comparing Apples to Oranges

Tue, 21 Mar 2017 11:59:15 +0000

When designing Workiva’s durable messaging system we took a hard look at using Amazon’s Kinesis as the message storage and delivery mechanism. At first glance, Kinesis has a feature set that looks like it can solve any problem: it can store terabytes of data, it can replay old messages, and it can support multiple message consumers. But if you dig a little deeper you will find that Kinesis is well suited for a very particular use case, and if your application doesn’t fit this use case, Kinesis may be a lot more trouble than it’s worth.

Software Architecture as Business Analysis

Mon, 20 Mar 2017 09:39:15 +0000

Architecture is the bridge between (often abstract) business goals and the final (concrete) resulting system.

– Software Architecture in Practice

The CONTROL project attempts to improve the interaction between users and computers during data analysis.

Traditional data analysis systems are a black box where a user enters a query, and waits for some amount of time before receiving a result. The CONTROL project aims to make this process interactive by continuously providing approximate results that are improved over time. Implementing such a system requires rethinking some fundamental tenants of database systems. First, with interactive systems queries may never complete, but instead they may be halted when results are “good enough”. Second, interactive systems must be able to provide approximate results quickly while maximizing the rate at which an accurate answer is found. This paper explores the changes in database technology needed to support interactive use cases.

How Much is That Going to Cost Anyway? Calculating Cost of Goods Sold

Sun, 26 Feb 2017 15:53:15 +0000

One of the realities of running a business is that you will — at some point — need to make money. This means you must sell something for more than it cost to make it.

Profit = Total Revenue - Total Expenses

So, to sell a service or feature (like a third-party API portal) at a profit, we need to understand how much it costs to make it, so we know how much to sell it for. In business parlance, the quantity we are looking for is the cost of goods sold — the accumulated costs used to create a good, including direct labor, materials, and any overhead.

Paper Review: An Array-Based Algorithm for Simultaneous Multidimensional Aggregates

Mon, 20 Feb 2017 05:33:12 -0600

Title and Author of Paper

An Array-Based Algorithm for Simultaneous Multidimensional Aggregates. Y. Zhao et al.

Summary

One of the core functions of an OLAP system is computing aggregations and group-by operations. This functionality has been characterized by the “Cube” operator, which computes group-by aggregations over all possible subsets of a specified dimension. As an example of the Cube operator, consider a model with the dimensions product, store, date, and the measured value sales. To compute the Cube for this data set requires computing sales for all subsets of the dimensions: sales by product, store, and date; sales by product and store; sales by product; etc. As a user, I want the system to prepare these results for me in response to ad-hoc queries or as part of a ETL job that prepares the data for analysis. Because there is a lot of data involved, the challenge of implementing the Cube operator is in computing these aggregations as efficiently as possible.

Italics in Vim

Thu, 16 Feb 2017 19:16:09 -0600

I write Markdown using Vim and the vim-pencil plugin and one of the things that particularly bothered me was that, by default, iTerm2 and the solarized colour scheme did not support italic text. I finally sat down this evening and got this working. Really, I just found and watched Greg Hurrel’s YouTube video explaining the whole thing.

To enable italics requires updating the terminfo database. Terminfo enables programs to use the terminal in a device-independent manner. For us, this means that it allows applications to lookup the correct escape codes for displaying italics. If the terminfo database has the correct escape codes present in the database, italics are displayed. If not? No italics.

Comparing Swagger with Thrift or gRPC

Thu, 09 Feb 2017 15:46:53 +0000

I’ve been asked recently, what’s the difference between Swagger and Thrift (or gRPC)? Although they look similar, they solve fundamentally different problems. Let’s look at the differences.

Swagger

At the most basic level, Swagger is a REST API specification language. The great part is that there is an entire ecosystem of tools built around this specification language to support API design, client and server code generation, and interactive documentation.

Key Features

REST + JSON API framework.
JSON requests and responses.
Code generation.
Documentation generation.

Thrift

Thrift is a software framework for supporting RPC. An interface definition language is used to describe your system in terms of data types and interfaces, the Thrift compiler generates client and server code that match your definition, and the Thrift library handles serialization and transport.

Being Good Enough

Tue, 31 Jan 2017 15:03:32 +0000

Better a diamond with a flaw than a pebble without. Confucius

We all want to have a perfect product, a perfect system, and a perfect development story. Unfortunately, reality is … reality. And it’s not perfect. One of the biggest struggles of engineering well is understanding the constant push and pull among the forces that govern the “rest of the business”, and governing your technological and development choices accordingly.

Do not strive for perfection. Strive to be good enough.

Yet Another S3 Static Site

Wed, 18 Jan 2017 11:59:15 +0000

Here it is. My version of the S3 static site.

This one is publishable through CloudFormation and uses CodeCommit and CodeBuild to regenerate and publish the site with every push to the host Git repository.

Any change to the CodeCommit Git repository automatically triggers a build through CodeCommit. This build runs the Hugo static site generator on your repo and syncs the results to an S3 bucket configured for serving a static site.

Packaging a Custom Boomi Connector

Tue, 17 Jan 2017 11:12:37 -0600

Having created a custom Boomi connector, the next step is packaging it as a Jar file for testing and release. This requires setting some configuration files that allow the Atom process to load and run your files.

Connector configuration file

The first configuration we need to set is the META-INF/connector-config.xml file. This file tells the Atom process which class implements your custom connector. This file must have a root XML element named GenericConnector and specify the class name of your connector — which must be the class that extends the BaseConnector class.

Creating a Custom Dell Boomi Connector

Mon, 16 Jan 2017 12:37:03 -0600

This article will show you how to create a custom connector for reading data from Dell Boomi. The connector will read the list of GitHub follower’s from the public GitHub API. This should provide an overview of how to write your own custom connector for a unique I/O source.

Prerequisites

To follow along, you need to have a valid Boomi licence (or free trial) to setup the Boomi Connector SDK. The SDK is written in Java so Java development experience is assumed.

Paper Review: Implementing Data Cubes Efficiently

Sat, 14 Jan 2017 08:21:31 -0600

Business intelligence and analytics use cases involve complex queries on potentially very large databases. To minimize query response times, query optimization is critical. One approach to optimizing query response times is to precompute relevant values ahead of time, and to use those precomputed results to answer queries. Unfortunately, it is not always feasible to precompute every potential value that is required to answer arbitrary queries. This paper describes a framework and presents algorithms that pick a good subset of queries to precompute to optimize response time.

Getting Started With Dell Boomi

Wed, 11 Jan 2017 09:24:21 -0600

This tutorial describes how to setup a test integration running Dell Boomi. For those not familiar, Boomi is an integration platform as a service that implements many of the integration patterns described in the book Enterprise Integration Patterns. It is a commercial alternative to the Apache Camel open source integration framework.

Boomi Overview

Boomi allows developers to run an integration Process, which is composed of an input stage, followed by data transformations and any business logic, followed by one or more output stages where the data is written out to a final destination.

Optimistic Locking in a REST API

Wed, 21 Dec 2016 14:32:35 +0000

In a REST application, it’s often the case that several clients might interact with a single resource, each holding a copy of the resources state. At any point in time, these client’s understanding of resource state may differ from each other or from the server. Without some way of realigning resource state, changes requested by a client based on an out-of-date understanding of resource may have undesired effects, from repeating computationally expensive requests to overwriting and losing another client’s changes.

Checking for null in an API Gateway transform

Mon, 19 Dec 2016 15:14:35 +0000

Amazon’s API Gateway provides the ability to transform a response from an endpoint into a different format for return to the client.

One thing I wished to accomplish with this was to return a value to the client, only if it was set in the response. Essentially, I wanted to check for the existence of a JSON property in the response, and react accordingly. The solution was not obvious to me, and this post serves to record that solution for posterity.

Effective Cache Control

Mon, 19 Dec 2016 15:10:35 +0000

The web supports a global network of billions of devices and users, and a key component of this support is effectively caching frequently accessed data along the request-response path. One of the key benefits in adopting a REST architectural style for your system is being able to leverage this existing infrastructure, taking advantage of the billions of dollars of investment already made in the web, and promoting loose coupling, performance and scalability.

Configuring REST-assured for Amazon API Gateway

Tue, 13 Dec 2016 12:21:53 +0000

As part of testing our Amazon API Gateway deployment, we set up JUnit tests to run automated Swagger/OpenAPI validation using Swagger Request Validator and REST-assured. This allows us to write simple tests in a fluent style, with automatic validation that requests and responses match the Swagger API specification deployed to API Gateway.

given()
        .log().all()
        .filter(validationFilter)
.when()
        .post("/oauth2/token")
.then()
        .assertThat()
        .statusCode(200);

Out of the box, REST-assured does not work with Amazon’s API Gateway endpoints using Java 8. Attempting to use it results in a handshake error when connecting to the API Gateway endpoint.

Paper Review: Robust Query Processing through Progressive Optimization

Fri, 18 Nov 2016 09:58:31 -0600

Title and Author of Paper

Robust Query Processing through Progressive Optimization. Markl et al.

Summary

Traditional query optimizers choose an execution plan for a query by using estimates of current database statistics. However, these estimates may be inaccurate, leading to overly expensive query plans being chosen and executed. This paper presents progressive query optimization, allowing query execution to detect and recover from estimation errors during processing.

During each execution step, progressive query optimization (POP) detects differences between the cardinality of the currently processed tuple and compares that to the estimated cardinality that was used to define the original execution plan. If those cardinalities differ enough, POP will re-optimize the query using updated estimates of cardinality. Any materialized views already computed can be reused during the re-execution step.

Creating a Service Oriented Organization

Sun, 30 Oct 2016 21:59:15 +0000

The decision to build products using a service-oriented (or microservice) architecture has enormous technical and organizational impact that is reflected in everything from how teams write code, to how they communicate, to how the organization itself is structured. Given the breadth and depth of impact this decision has, it pays to reflect on why an organization chooses a service oriented architecture, how an organization can support such an architecture, and how teams and individuals can support the organization in successfully adopting a service oriented platform.

Understanding API Gateway Payload Mappings

Fri, 21 Oct 2016 09:41:35 +0000

Amazon’s API Gateway provides the facilities to map an incoming request’s payload to match the required format of an integration backend.

API Gateway Payload Mapping

API Gateway uses the concept of “models” and “mapping templates” to specify the mapping between the client payload and the server payload.

Models

A model defines the structure of the incoming payload using JSON Schema. The model is an optional, but not required, piece of API Gateway. By providing a model, you make it easier to define the upcoming mapping template that actually does the transformation between the client and server.

Securing a Swagger API with OAuth2

Wed, 19 Oct 2016 15:46:53 +0000

In our previous article on Swagger, we defined a Player API modelling GET access to a Player resource. In this article, I show how to use Swagger’s security models to to deploy this API using an OAuth2 configuration.

Swagger handles authentication and authorization using a combination of a “Security Definitions” Object and a list of “Security Requirements” Objects. Each of these definitions are applied at the top-level of your Swagger specification.

How to deploy a Swagger specification to Amazon API Gateway using CloudFormation

Tue, 18 Oct 2016 10:32:35 +0000

Full sample code for this article is available on Github.

Aamazon’s API Gateway supports the direct importing of Swagger specification files using CloudFormation rules. To do this, you have two choices. Injecting the swagger.json or swagger.yaml file directly into the Body field of the CloudFormation template, or uploading the swagger.json or swagger.yaml file to an S3 location and setting that location as the BodyS3Location field of the CloudFormation template.

A minimal YAML template is listed below:

Designing a Swagger API

Wed, 12 Oct 2016 15:46:53 +0000

The goal of Swagger is to define a standard interface for describing REST APIs. In an ideal world, a Swagger definition for your API will allow both humans and computers to discover and understand your API. At it’s core, Swagger is a formal specification of an API. Surrounding this specification are a wide swath of tools to support creating documentation, providing client libraries, and managing API deployments.

One of Swagger’s original goal was to provide a way to document an API in both a human and machine readable way. Swagger provides such a documentation format for RESTful APIs. By augmenting this documentation format with tools for API clients and developers, Swagger grew into an ecosystem providing for API developers and consumers.

What is OSGi? Microservices for the JVM

Tue, 11 Oct 2016 11:34:28 -0600

As someone who is being recently re-introduced to the Java platform, there are a lot of components and pieces to become familiar with. One of those pieces is OSGi, a service registry and deployment specification for Java apps.

The OSGi specification describes a complete environment for running Java applications as components. Each component is a bundle that can be remotely installed, started, stopped, updated or uninstalled. In addition, OSGi provides a service registry that allows existing services to detect the addition or removal of other services and adapt accordingly.

Paper Review: The Volcano Optimizer Generator: Extensibility and Efficient Search

Tue, 11 Oct 2016 09:34:37 -0600

Title and Author of Paper

The Volcano Optimizer Generator: Extensibility and Efficient Search. Goetz Graefe and William J. McKenna.

Summary

The query optimizer’s job is to take user input in the form of SQL and generate a cost-efficient plan for satisfying that query using the underlying physical layout of the database. This paper describes Volcano, a system for taking a data model, logical algebra, physical algebra, and optimization rules and translating them into optimizer source code.

Paper Review: Dynamo: Amazon’s Highly Available Key-value Store

Fri, 07 Oct 2016 10:59:32 -0600

Title and Author of Paper

Dynamo: Amazon’s Highly Available Key-value Store, DeCandia et al.

Summary

Dynamo, as the title of the paper suggests, is Amazon’s highly available key-value storage system. Dynamo only supports primary-key access to data, which is useful for services such as shopping carts and session management. Dynamo’s use case for these services is providing a highly-available system that always accepts writes. This requirement forces the complexity of conflict resolution to data readers. Writes are never rejected.

0 to Message in 60 Seconds: Getting Started with Amazon SQS

Wed, 05 Oct 2016 18:29:21 +0000

Amazon Simple Queue Service (SQS) is a message queue service that allows applications to reliably queue messages from one system component to be consumed by another component. Adding a queue between application components allows them to run independently, effectively decoupling applications by providing a buffer between producers of data and their consumers.

Up and Running

This section provides a guide to getting up and running with SQS using a fictional music store as an example. This music store has the ability to notify clients of any upcoming events via SQS.

Paper Review: Cap Twelve Years Later: How the “Rules” Have Changed

Wed, 05 Oct 2016 06:07:31 -0600

Title and Author of Paper

Cap Twelve Years Later: How the “Rules” Have Changed. Eric Brewer.

Summary

This article provides an exploration of the CAP Theorem and how it relates to database system design. The author argues that, since partitions are likely to happen, the system designer can introduce methods for safely recovering from partitions to compensate. This strategy allows the database to continue to provide availability during a partition, and enforce consistency once the partition is resolved.

Integrating Applications: From RPC to Messaging

Tue, 04 Oct 2016 11:06:57 +0000

When integrating two independent services you have two options: making a remote procedure call (RPC), or sending a message. Which should you choose?

What is a Remote Procedure Call?

An organization often needs to share data and processes between multiple independent processes in a responsive way. For example, updating a user’s name in a shipping system may trigger updates in a billing system. The shipping system could update the billing system’s data directly by modifying a shared database, but this approach requires the shipping system to know far too much about the internal processes of the billing system. Instead, the business system can encapsulate the update operation behind an interface in the form of a remote procedure call, or RPC.

Integrating Applications

Sun, 25 Sep 2016 14:03:15 +0000

A big portion of any software engineering revolves around integrating multiple, disparate applications into a cohesive and functional whole. These apps may be built in house or third-party, or they may run on your network or distributed geographically, or they may be microservices designed to integrate. In any of these cases, you have several different options for integration, each with pros and cons.

The integration patterns listed here are ordered by least to most sophisticated, but also by least to most complex.

Tests are Never Enough

Fri, 23 Sep 2016 11:35:57 +0000

The request was fairly simple — iterate through some data and update some dates. Something as simple as this.

for entry in db.query():
    entry.date = entry.date + timedelta(days=10)
    entry.put()

Unfortunately, the NoSQL database we were using did not support schemas and, unbeknownst to me, some data had been changed in unexpected ways on production. Something as simple as this.

Notice the Outlier?

My code seemed correct. Unit tests passed. Code review passed. It ran flawlessly on the test environment. QA signed off on the change. So we deployed it. And things broke.

The Problem with Point to Point Communication

Wed, 31 Aug 2016 19:40:15 +0000

Point-to-point communication between servers usually works just fine when one or two instances are communicating.

One or two instances communicating

However, if you increase the number of applications, the total number of connections increases.

Three instances communicating

In fact, the total number of connections increases as a square of the number of application instances. So, if you are running 100 instances, you will be maintaining O(100^2) connections. The scaling becomes quite painful.

A Guided Tour Through Thrift

Tue, 23 Aug 2016 08:12:12 -0600

After reading the Thrift whitepaper and sending your first message, you may still have some questions about how Thrift actually works. This article helps answer those questions by providing a guided tour through the Apache Thrift architecture, highlighting the protocols, transports, and compiler, and how they interact with each other.

Thrift from 10,000 feet

At a high-level, Thrift is organized into several layers as in Figure 1. The layers highlighted in yellow represent application code that is written by a user. The portions in red represent code generated by the Thrift compiler from an interface definition defined in an IDL file. The layers in orange are portions of Thrift available as library code imported into your application as a dependency. Lastly, the device layer in blue represents the physical device transmitting messages.

Stability Anti-Patterns

Mon, 15 Aug 2016 19:40:15 +0000

I recently finished reading the excellent book “Release It!” by Michael Nygard. One of the key points that I wanted to remember was the stability anti-patterns. So, this post will serve as a reminder of architectural smells to look out for when designing production systems.

This list of anti-patterns are common forces that will create or accelerate failures in production systems. Given the nature of distributed systems, avoiding these patterns is not possible. You must accept that they will happen, and program your application to be resilient to these failures.

Metrics-Driven Development

Tue, 09 Aug 2016 12:14:57 +0000

Metrics-Driven Development is an emerging term developing from the practices of continuous integration, continuous delivery, dev ops, and agile software methodologies. This article serves to define what metrics-driven development is, why it is useful, and how to use it to drive software changes.

Let’s start with a definition of metrics-driven development.

Metrics-Driven Development (MDD): The use of real-time metrics to drive rapid, precise, and granular software iterations.

This definition is simple and straightforward, but does leave room for interpretation. Let’s dive deeper and break the definition down, bit-by-bit.

Testing a Producer-Consumer Design using a CyclicBarrier

Thu, 21 Jul 2016 13:57:12 -0600

Testing concurrent objects can be challenging. One particular pattern that is useful for objects used in producer-consumer designs is to ensure that everything put in to a shared concurrent queue by a producer is correctly executed by consumers.

Paper Review: Generalized Isolation Level Definitions

Thu, 23 Jun 2016 06:00:31 -0600

Disk I/O has been the primary limiting factor in database performance for most commercial databases. However, as prices of main-memory have dropped it has become feasible to keep the entire working set of a database in RAM. With this architectural change, it makes sense to evaluate database design decisions made to avoid disk I/O to see which ones still hold promise in a main-memory world. This paper provides such a performance analysis.

Getting Started with Amazon Flow Framework

Thu, 02 Jun 2016 11:59:15 +0000

Amazon’s Flow Framework provides a high-level SDK for interacting with the Amazon Simple Workflow service (SWF). SWF is a managed service that helps developers build, run and monitor parallel or sequential asynchronous workloads. SWF reliably commits your workflow’s state to durable storage, allowing you to focus on your business logic rather than on the complex coordination of distributed services.

Writing an application with the flow framework can be divided into the following steps:

Paper Review: Hekaton: SQL Server’s Memory-Optimized OLTP Engine

Fri, 27 May 2016 06:00:31 -0600

Title and Author of Paper

Hekaton: SQL Server’s Memory-Optimized OLTP Engine, Diaconu et al.

Summary

Database design has traditionally revolved around efficient access to disk. However, recent memory prices make it feasible to keep the majority (or entirety) of a database in main-memory. A main-memory design requires a few adjustments to maximize concurrency, handle transactions, and recover after failure. This paper describes such a design in relation to the development of Hekaton — an extension to Microsoft’s SQL Server. With Hekaton, if the user specifies that a table is “memory-optimized”, this triggers SQL Server to store that table entirely in memory, allowing Hekaton to optimize the table with its in-memory database engine.

Paper Review: C-Store: A column-oriented DBMS

Wed, 25 May 2016 06:07:31 -0600

Title and Author of Paper

C-Store: A column-oriented DBMS. Stonebraker et al.

Summary

In traditional databases, all attributes of a record (or tuple) are stored together as a contiguous block. When writing to disk, a single write pushes all fields of the record to disk. For the purposes of this paper, we call this type of DBMS a write-optimized system and this type of system works well for transactional processing. However, for querying data we can do better with a system that is read-optimized. C-Store is such a read-optimized system.

Concurrency: A Primer

Tue, 17 May 2016 15:39:37 -0600

Writing correct programs is hard; writing correct concurrent programs is harder. Java Concurrency in Practice.

So, why bother with concurrency? A number of reasons:

Concurrency provides a natural method for composing asynchronous code.
Concurrency allows your program to avoid blocking user operations.
Concurrency provides one of the easiest ways take advantage of multi core systems.

As processor counts increase, exploiting concurrency will be an even more important facet of high performance systems. Yet, before diving in to writing a concurrent program, it pays to understand the fundamentals of concurrency. To aid in such understanding, this article will provide background material on concurrency and an exploration of different methods for managing state and different models for writing concurrent program. The article is split into three main sections:

Server-to-server OAuth with the Google OAuth Client Library for Java

Thu, 12 May 2016 13:27:12 -0600

This post describes how to validate a JWT token using the Google OAuth library for making server-to-server OAuth requests.

First, there is a prerequisite of being able to read a key file from your local file system. This key file is obtained from the system that you wish to authorize against and contains the private-key pair authorizing your server with the other system.

/**
 * Return private key from a file. Must be a valid PEM file with PKCS#8 encoding standard.
 *
 * @return a private key
 */
PrivateKey loadPrivateKey(File keyFile) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
  byte[] content = Files.toByteArray(keyFile);
  PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(content);
  return KeyFactory.getInstance("RSA").generatePrivate(ks);
}

Thoughts On Google Cloud Platform Next

Mon, 28 Mar 2016 15:20:12 -0600

I was fortunate enough to attend Google Cloud Platform Next last week and wanted to summarize a few of my thoughts on the conference. As I sat down to analyze the event, I found a few distinct themes that I would like to expand on.

Multi-Cloud

Google is serious about multi-cloud support for their monitoring and integration products. As a cynic, if Google wants to steal customers from Amazon, offering tools to aid the transition is in their best interest. As a realist, most companies will continue to operate in a multi-cloud environment to take advantage of the strengths of each platform, and it’s nice to see Google recognizing this fact and working within it. Either way, I think being open about supporting AWS is a good thing.

Paper Review: Access Path Selection in a Relational Database Management System

Tue, 15 Mar 2016 06:00:31 -0600

Title and Author of Paper

Access Path Selection in a Relational Database Management System. P. G. Selinger et al.

Summary

This paper describes methods of the SQL query optimizer for determining the cost of satisfying a query. It also describes methods for choosing among several competing methods.

What are the motivations for this work?

SQL is a high-level language where requests for data are stated non-procedurally. The user is not expected to need any knowledge of how the data is stored in the database or how it is retrieved. Thus, it is up to the DBMS to choose an appropriate access path for data retrieval on the users behalf. By designing the database in this fashion, we preserve data independence, where a users view of the data is independent of the databases view of the data.

Paper Review: Eddies: Continuously Adaptive Query Processing

Tue, 15 Mar 2016 06:00:31 -0600

Title and Author of Paper

Eddies: Continuously Adaptive Query Processing. Ron Avnur and Joseph M. Hellerstein.

Summary

Eddies describes a query optimization system that continuously reorders operators in a query plan as the it runs. This insight is based on the observation that assumptions made about the database at the time that a query is submitted will rarely hold throughout the duration of query processing.

Query plans can be reordered using two criteria: synchronization barriers and moments of symmetry. Synchronization barriers exist whenever an operator is waiting for a table scan to complete before making forward progress. In general, these barriers limit concurrency and one goal of the eddies system is to avoid or improve these barriers by selecting an appropriate join algorithm.

Paper Review: The Gamma Database Machine Project

Wed, 09 Mar 2016 06:00:31 -0600

Title and Author of Paper

The Gamma Database Machine Project. David J. DeWitt et al.

Summary

This paper presents the research undertaken at the University of Wisconsin-Madison to develop a scalable database architecture. The paper presents novel methods for scaling a database cluster using a shared-nothing architecture, and for using hash-based join algorithms to parallelize the workload across the cluster.

What are the motivations for this work?

The motivation behind Gamma was to support horizontally scalable database using commodity parts.

Local Development with the Kinesis Client Library

Fri, 04 Mar 2016 13:27:31 -0600

I’ve been working on an application to read data from a Kinesis using the Kinesis Client Library for Java. One requirement was to be able to run the application locally during development. This requires configuring Kinesis, DynamoDB, and CloudWatch to work locally.

Dynalite

Getting a local copy of DynamoDB running is easily done using the dynalite library.

> npm install -g dynalite
> dynalite --port 7000

Kinesalite

A local copy of Kinesis is found with the kinesalite library.

Paper Review: The Design of POSTGRES

Fri, 04 Mar 2016 05:42:11 -0600

Title and Author of Paper

The Design of POSTGRES, Michael Stonebraker and Lawrence A. Rowe.

Summary

Postgres started as a research project to extend the standard database architecture to support several additional concepts: complex objects as values, user-defined data types and procedures, and alerting and triggers.

This paper describes the system architecture designed to achieve these goals, while retaining functionality of the relational model. Although the design incorporates additional ideas such as time varying data, I will focus my review on the user-defined types and alerting scenarios.

Paper Review: System R: Relational Approach to Database Management

Wed, 02 Mar 2016 06:00:31 -0600

Title and Author of Paper

System R: Relational Approach to Database Management. M. M. Astrahan et al.

Summary

It’s hard to overstate the influence that the System R project had on database design and implementation. After reading this paper it is clear that traditional database architecture has not significantly changed since the System R project. System R provided the first implementation of SQL, the first demonstration of performant transactions, and provided the foundational groundwork in concurrency control and query optimization.

The Five Stages of NoSQL

Sun, 28 Feb 2016 17:10:12 -0600

Imagine a fledgling software startup consisting of one or two developers. They are following the lean startup methodology by throwing ideas and implementations at a wall to see what sticks. This methodology demands keeping your application as simple as possible until you find the optimum market. An on-going concern for the developers is finding a simple, flexible way to store application data: NoSQL or SQL?

The NoSQL database offers a premium out-of-the-box experience: install a package, start the database, and post and retrieve data using a JSON API. And by eschewing the details of a schema and the inconvenience of data modelling, the NoSQL database allows for fast iteration.

Paper Review: Architecture of a Database System

Wed, 24 Feb 2016 05:33:12 -0600

Title and Author of Paper

Architecture of a Database System. Joseph M. Hellerstein, Michael Stonebraker, James Hamilton.

Summary

Architecture of a Database System provides an explanation of how to implement a relational database. It begins with an architectural overview of the main parts of a database system as viewed through the life of an SQL query. This includes how the query is received, parsed and optimized and how the resulting data is returned from storage as part of a transaction.

Generating Java with JCodeModel

Sun, 21 Feb 2016 21:10:12 -0600

Have you come across the misfortune of needing to auto-generate Java source code? Luckily, anything you’ve wanted to do with Java has already been done — and auto-generating Java is no different. I recently used JCodeModel to translate from JSON to Java — it worked great but it lacks any tutorial-style documentation. This article means to fill that gap. If you feel the need to go more in-depth, consult the the Javadoc.

Writing an Apache Beam Batch Sink

Thu, 11 Feb 2016 22:12:18 -0600

This article describes how you can use the Dataflow/Beam SDK to write files to an S3 bucket by implementing a Sink.

A Sink has three phases: initialization, writing, and finalization. The initialization phase is a sequential process where you can create necessary preconditions such as output directories. The write phase lets workers write bundles of records to the Sink. The finalization phase allows for cleanup like merging files or committing writes.

Deploying a Druid Cluster with Ansible

Tue, 02 Feb 2016 05:41:48 +0000

During my continued education on Ansible I’ve writing some roles for deploying a Druid cluster to AWS similar to the article on deploying Zookeeper with Ansible.

The methods are fairly simple so rather than going through a detailed explanation I will just leave a link to the full source Github. Any and all contributions are welcome!

Paper Review: What Goes Around Comes Around

Wed, 27 Jan 2016 05:21:37 -0600

Title and Author of Paper

What Goes Around Comes Around. Joseph M. Hellerstein and Michael Stonebraker.

Summary

What Goes Around Comes Around summarizes several methods for modelling data within a database system. Each data model is described and the benefits and drawbacks listed as lessons learned from research into that model. The authors clearly present their opinions on each model and help readers unfamiliar with past modelling attempts understand the history of this area of research.

Deploying Zookeeper with Exhibitor to AWS using Ansible

Fri, 15 Jan 2016 09:46:48 +0000

This article provides a detailed guide of deploying Zookeeper to AWS using Exhibitor for cluster management. Exhibitor is a great help for managing your cluster but getting things up and running is not well documented. Hopefully this article corrects that deficiency.

Getting to Know Cloud Dataflow

Mon, 04 Jan 2016 09:12:37 -0600

Cloud Dataflow is Google’s managed service for batch and stream data processing. Dataflow provides a programming model and execution framework that allows you to run the same code in batch or streaming mode, with guarantees on correctness and primitives for correcting timing issues. Why should you care about Dataflow? A few reasons. First, Dataflow is the only stream processing framework that has strong consistency guarantees for time series data. Second, Dataflow integrates well with the Google Cloud Platform and provides seamless methods for reading from and writing to the Datastore, PubSub, BigQuery and Cloud Storage. Third, the Dataflow SDK is open source and has received contributions for interfacing with Hadoop, Firebase, and Salesforce — AWS integration is absolutely possible. Lastly, Dataflow is completely managed, whereas competing offerings such as Spark and Flink typically run on top of a Hadoop installation used for intermediate storage.

Docker Step By Step: Containerizing Zookeeper

Fri, 04 Dec 2015 10:48:21 -0600

Follow along with this article as we take a guided tour of containerizing Zookeeper using Docker. This guide will show how to install Zookeeper to the container, how to configure the Zookeeper application, and how to share data volumes between the host and container.

Why Java? Tales from a Python Convert

Fri, 20 Nov 2015 12:01:52 -0600

Whenever I tell people I’ve been working with Java I get the same reaction:

“Yuck! Java? Why Java?”

And, admittedly, I had the same reaction — at first. But over time, I’ve come to appreciate Java for its type safety, performance, and rock-solid tooling. I’ve also come to notice that this isn’t the Java I was used to — it’s been steadily improving over the last ten years.

Including a local package as a Maven dependency

Thu, 12 Nov 2015 13:57:12 -0600

Lately I’ve been tasked with developing a Java library for internal use. For testing, its proved useful to package the library for local use. This article describes how to add a Jar file to a local Maven repository for use in your own testing and development.

Create your local Maven repository

Your local Maven repository lives within the project you are developing for. Creating your local repository is as simple as making a new directory.

Configuring an Upstream Remote

Sun, 01 Nov 2015 21:10:21 -0600

This is something I often do but rarely remember the steps for. This post is intended to serve as a reminder for me and anyone else having the same question: how to add an upstream remote git repository.

Start by forking the repository you are contributing to and cloning that repository to your local file system. In this example, we will use the Elasticsearch repository and assume you have cloned it locally.

Writing Repeated BigQuery records using the Java Client Library

Tue, 27 Oct 2015 06:05:37 -0600

I’ve recently been working with Java via the Google Cloud Dataflow SDK. One problem I’ve had is working with the BigQuery Java Client. It was never entirely clear how to create a repeated record. This article explains how it works and how you can accomplish the same thing.

First, you need to create a new TableRow. For this example, let’s assume we are logging events using a guid and a timestamp.

From JSON to a Google API Client Library object

Sun, 25 Oct 2015 06:57:12 -0600

I have been working on a Cloud Dataflow project that parses incoming App Engine logs to generate status statistics such as numer of errors in the last 10 minutes. The incoming data is a JSON representation of a LogEntry object. A LogEntry object is represented in Java as a LogEntry class. The task I found myself in was converting the JSON representation of a LogEntry into the Java object for downstream processing.

A Maven runner for vim-test

Fri, 16 Oct 2015 09:22:09 -0600

If you haven’t tried vim-test yet, please do. It provides a consistent interface for running unit tests from within vim for a variety of languages and test runners. It also has support for different methods of dispatching your tests from vim to a terminal to retrieve the results.

vim-test works out of the box for a number of languages and is easily extensible to support additional languages. In fact, I recently contributed a Maven test runner for the Java language. If you are developing a Maven project, you can now run your tests from within vim using vim-test.

Deploying Kafka to Google Compute Engine

Mon, 12 Oct 2015 06:15:13 -0600

This article provides a startup script for deploying Kafka to a Google Compute Engine instance. This isn’t meant to be a production-ready system — it uses the Zookeeper instance embedded with Kafka and keeps most of the default settings. Instead, treat this as a quick and easy way do Kafka development using a live server.

This article uses Compute Engine startup scripts to install and run Kafka on instance startup. Startup scripts allow you to run arbitrary Bash commands whenever an instance is created or restarted. Since this script is run on every restart, we lead with a check that makes sure we have not already ran the startup script and, if we have, we simply exit.

Kafka Quick Start Guide

Wed, 30 Sep 2015 06:30:42 -0600

If you’ve read the previous article describing Kafka in a Nutshell you may be itching to write an application using Kafka as a data backend. This article will get you part of the way there by describing how to deploy Kafka locally using Docker and test it using kafkacat.

Running Kafka Locally

First, if you haven’t already, download and install Docker. Once you have Docker installed, create a default virtual machine that will host your local Docker containers.

Kafka in a Nutshell

Fri, 25 Sep 2015 06:20:42 -0600

Kafka is a messaging system. That’s it. So why all the hype? In reality messaging is a hugely important piece of infrastructure for moving data between systems. To see why, let’s look at a data pipeline without a messaging system.

This system starts with Hadoop for storage and data processing. Hadoop isn’t very useful without data so the first stage in using Hadoop is getting data in.

Bringing Data in to Hadoop

So far, not a big deal. Unfortunately, in the real world data exists on many systems in parallel, all of which need to interact with Hadoop and with each other. The situation quickly becomes more complex, ending with a system where multiple data systems are talking to one another over many channels. Each of these channels requires their own custom protocols and communication methods and moving data between these systems becomes a full-time job for a team of developers.

Beginning Docker

Mon, 14 Sep 2015 20:26:21 -0600

I’m writing this article as a means of tracking commonly used docker commands in a place where I won’t forget them. If you find it useful or have additional suggestions let me know in the comments.

A Review of the Coursera Data Science Specialization

Thu, 10 Sep 2015 06:29:12 -0600

A Review of the Coursera Data Science Specialization

I recently completed the 10th and final course in the Data Science Specialization offered by Coursera in conjunction with Johns Hopkins University. My background is as a computer scientist and programmer looking to learn more about statistical analysis and machine learning — I have always had an interest in data analysis and machine learning but never actually studied it. I used the Data Science Specialization acted as a starting point to learn more about the field and become familiar with typical problems and solutions that data scientists encounter in the field. This article describes my experience with the specialization and answers the question of whether or not the it is worth the time.

Counting N-Grams with Cloud Dataflow

Wed, 05 Aug 2015 05:41:06 +0000

Counting n-grams is a common pre-processing step for computing sentence and word probabilities over a corpus. Thankfully, this task is embarrassingly parallel and is a natural fit for distributed processing frameworks like Cloud Dataflow. This article provides an implementation of n-gram counting using Cloud Dataflow that is able to efficiently compute n-grams in parallel over massive datasets.

The Algorithm

Cloud Dataflow uses a programming abstraction called PCollections which are collections of data that can be operated on in parallel (Parallel Collections). When programming for Cloud Dataflow you treat each operation as a transformation of a parallel collection that returns another parallel collection for further processing. This style of development is similar to the traditional Unix philosophy of piping the output of one command to another for further processing.

N-gram Modeling With Markov Chains

Fri, 31 Jul 2015 06:23:43 -0600

A common method of reducing the complexity of n-gram modeling is using the Markov Property. The Markov Property states that the probability of future states depends only on the present state, not on the sequence of events that preceded it. This concept can be elegantly implemented using a Markov Chain storing the probabilities of transitioning to a next state.

Modeling Natural Language with N-Gram Models

Sat, 25 Jul 2015 06:41:06 +0000

One of the most widely used methods natural language is n-gram modeling. This article explains what an n-gram model is, how it is computed, and what the probabilities of an n-gram model tell us.

Structuring an Application using Model View Controller

Thu, 09 Jul 2015 19:40:15 +0000

Early pioneers in object-oriented programming paved the path towards using Model View Controller (MVC) for graphical user interfaces as early as 1970 and web applications have continued using the pattern to separate business logic from display. This article attempts to clarify the use of Model View Controller within web applications — giving consideration to the fact that most developers will be building their application using an existing web framework.

Managed VMs and the Future of App Engine

Tue, 23 Jun 2015 20:33:37 -0600

I’ve been thinking about the transition of App Engine to Python 3 and have come to the conclusion that it will never happen — App Engine will eventually be deprecated in favour of Managed VMs. Let’s break this apart to see why this is.

First, consider the effort required by Google to develop App Engine. The Python runtime environment was modified to enforce the sandbox of the App Engine environment. To provide a Python 3 environment for App Engine as we know it, the Python 3 runtime would need to be modified with the same restrictions. Even imagining that this would happen for Python 3.4, the effort to upgrade to Python 3.5 would require additional effort by Google to modify the runtime.

Introducing CloudPyPI

Tue, 16 Jun 2015 21:19:26 -0600

A common problem with Python development for large-scale teams is sharing internal libraries. At Vendasta we’ve been solving this problem using a private PyPI installation running on Google App Engine with Python eggs and wheels being served by Google Cloud Storage. Today, we are announcing the open source version of this tool — CloudPyPI.

CloudPyPI is a modification of pypiserver for running on Google App Engine. We’ve also introduced a simple user management system to allow authenticated access to your Python packages. Together, we’ve found this to be a robust tool for distributing private Python libraries internally. If this is a problem you’ve been trying to solve, give CloudPyPI a try — contributions and feature requests are always welcome.

App Engine Pipelines API - Part 6: The Pipeline UI

Tue, 09 Jun 2015 20:43:56 -0600

View all articles in the Pipeline API Series.

This article will serve as a reminder of the Pipeline UI as much for the writer as for the reader. The Pipeline UI requires the MapMeduce library to be installed. If you are not familiar with MapReduce please refer to the MapReduce API Series of articles.

Once MapReduce is installed you will need to add a few indices to index.yaml to properly query for pipeline records for display in the UI.

App Engine Pipelines API - Part 5: Asynchronous Pipelines

Tue, 02 Jun 2015 04:45:56 -0600

View all articles in the Pipeline API Series.

This article will cover fully asynchronous pipelines. The term ‘asynchronous’ is misleading here — all piplines are asynchronous in the sense that yielding a pipeline is a non-blocking operation. An asynchronous refers to a pipeline that remains in a RUN state until outside action is taken, for example, a button is clicked or a task is executed.

Marking a pipeline as an asynchronous pipeline is as simple as setting the async class property to True.

App Engine Pipelines API - Part 4: Pipeline Internals

Wed, 27 May 2015 05:57:19 -0600

View all articles in the Pipeline API Series.

We’ve learned how to execute and chain together pipelines, now let’s take a look at how pipelines execute under the hood. If necessary, you can refer to the source code of the pipelines project to clarify any details.

The Pipeline Data Model

Let’s start with the pipeline data model. Note that each Kind defined by the pipelines API is prefixed by _AE_Pipeline, making it easy to view individual pipeline details by viewing the datastore entity.

App Engine Pipelines API - Part 3: Fan In, Fan Out, Sequencing

Tue, 19 May 2015 05:57:19 -0600

View all articles in the Pipeline API Series.

Last time, we studied how to connect two pipelines together. In this post, we expand on this topic, exploring how to fan-out to do multiple tasks in parallel, fan-in to combine multiple tasks into one, and how to do sequential work.

App Engine Pipelines API - Part 2: Connecting Pipelines

Tue, 12 May 2015 05:57:19 -0600

View all articles in the Pipeline API Series.

Last time, we discussed basic pipeline instantiation and execution. This time, we will cover sequential pipelines, answering the question “How do I connect the output of one pipeline with the input of another pipeline”?

App Engine Pipelines API - Part 1: The Basics

Tue, 05 May 2015 05:57:19 -0600

View all articles in the Pipeline API Series.

The Pipelines API is a general purpose workflow engine for App Engine applications. With the Pipelines API we can connect together complex workflows into a coherent run time backed by the Datastore. This article provides a basic overview of the Pipelines API and how it can be used for abritrary computational workflows.

In the most basic sense a Pipeline is an object that takes input, performs some logic or computation on that input, and produces output. Pipelines can take two general forms – synchronous or asynchronous. Synchronous pipelines act as basic functions that must complete during a single request. Asynchronous pipelines spawn child pipelines and connect them together into a workflow by passing input and output parameters around.

Durabledict for App Engine

Wed, 29 Apr 2015 06:19:23 -0600

tldr;

DatastoreDict.

What’s a durabledict?

Good question. Durabledict is a Python implementation of a persistent dictionary. The dictionary values are cached locally and sync with the datastore whenever a value in the datastore changes.

Disqus provides concrete implementations for Redis, Django, ZooKeeper and in memory. This blog post details an implementation using the App Engine datastore and memcache.

Creating your own durabledict

By following the guide the durabledict README we can create our own implementation. We need to subclass durabledict.base.DurableDict and implement the following interface methods. Strictly speaking, _pop and _setdefault do not have to be implemented but doing so makes your durabledict behave like a base dict in all cases.

Continuous Delivery Distilled

Thu, 23 Apr 2015 08:32:37 -0600

What if you could deliver more value, with more speed and with more stability?

What if you could triage bugs faster?

What if you could fix bugs easier and with less user facing impact?

You can, with continuous delivery.

Terminology

First, some terminology. What distinguishes continuous integration, continuous deployment and continuous delivery? Continuous integration revolves around the continuous automated testing of software whenever change to the software is made. Continuous deployment is the practice of automatically deploying any change to the code. Continuous delivery implies that you can deploy any change to production but for any number of reasons you may choose not to. The focus of this article is on continuous delivery.

Creating a BigQuery Table using the Java Client Library

Mon, 23 Mar 2015 15:32:37 -0600

I haven’t been able to find great documentation on creating a BigQuery TableSchema using the Java Client Library. This blog post hopes to rectify that :).

You can use the BigQuery sample code for an idea of how to create a client connection to BigQuery. Assuming you have the connection set up you can start by creating a new TableSchema. The TableSchema provides a method for setting the list of fields that make up the columns of your BigQuery Table. Those columns are defined as an Array of TableFieldSchema objects.

Deploying R Studio on Compute Engine

Mon, 23 Mar 2015 15:32:37 -0600

Sometimes you have a data analysis problem that is just too big for your desktop or laptop. The limiting factor here is generally RAM. Thankfully, services like Google Compute Engine allow you to lease servers with up to 208GB of RAM, large enough for a wide variety of intensive tasks. An ancillary benefit of using a service like Compute Engine is that it allows you to easily load your data from a Cloud Storage Bucket, meaning you don’t need to keep a copy of the large dataset locally at all times.

Keeping App Engine Search Documents and Datastore Entities In Sync

Mon, 23 Feb 2015 08:20:37 -0600

At Vendasta the App Engine Datastore serves as the single point of truth for most operational data and the majority of interactions are against this single point of truth. However, a piece of required functionality in many of our products is to provide a searchable view of the data in the App Engine Datastore. Search is difficult using the Datastore and so we have moved to using the Search API as a managed solution for searching datastore entities. In this use case, every edit to an entity in the Datastore is reflected as a change to a Search Document. This article details an architecture for keeping Datastore entities and Search Documents in sync throughout failure and race conditions.

Halting Python unittest Execution on First Error

Thu, 12 Feb 2015 06:20:37 -0600

We all know the importance of unit tests. Especially in a dynamic language like Python. Occasionally you have a set of unit tests that are failing in a cascading fashion where the first error case causes subsequent tests to fail (these tests are likely no longer unit tests, but that’s a different discussion). To help isolate the offending test case in a see of failures you can set the unittest.TestCase class to halt after the first error by overriding the run method as follows.

Create a Google Cloud Dataflow Project with Gradle

Wed, 11 Feb 2015 06:20:37 -0600

I’ve been experimenting with the Google Cloud Dataflow Java SDK for running managed data processing pipelines. One of the first tasks is getting a build environment up and running. For this I chose Gradle.

We start by declaring this a java application and listing the configuration variables that declare the source compatibility level (which for now must be 1.7) and the main class to be executed by the run task to be defined later.

A pypiserver Deployment Script

Sun, 01 Feb 2015 14:53:37 -0600

At Vendasta we’ve been slowly adopting pypi and pip for our internal code libraries and the time has come to deploy our own private pypi server. After evaluating a few options I settled on the simplistic pypiserver – a barebones implementation of the simple HTTP API to pypi.

The deployment uses nginx as a front-end to pypiserver. pypiserver itself is ran and monitored using supervisord. I created a bash script that creates a user and group to run pypiserver and installs and runs nginx, supervisord and pypiserver. I’ve been running this bash script through Vagrant to deploy a custom pypiserver for private use. I wanted to save this code for posterity and hopefully help someone else working on the same task.

Downloading files from Google Cloud Storage with webapp2

Tue, 27 Jan 2015 06:07:12 -0600

I’ve been working on a simple App Engine application that offers upload and download functionality to and from Google Cloud Storage. When it came time to actually download the content I needed to write a webapp2 RequestHandler that will retrieve the file from Cloud Storage and return it to the client.

Querying App Engine Logs with Elasticsearch

Fri, 23 Jan 2015 06:15:07 +0000

From a DevOps perspective having a historical record of application logs can aid immensely in tracking down bugs, responding to customer questions, or finding out when and why that critical piece of data was updated to the wrong value. One of the biggest grievances with the built-in log handling of Google App Engine is that historical logs are only available for the previous three days. We wanted to do a little bit better and have logs available for a 30 day time period. This article outlines a method we’ve developed for pushing App Engine logs to an elasticsearch cluster.

Parsing bash script options with getopts

Sun, 04 Jan 2015 12:31:51 +0000

A common task in shell scripting is to parse command line arguments to your script. Bash provides the getopts built-in function to do just that. This tutorial explains how to use the getopts built-in function to parse arguments and options to a bash script.

Managing App Engine Dependencies Using pip

Tue, 30 Dec 2014 20:35:48 +0000

One unfortunate difficulty when working with App Engine is managing your local dependencies. You don’t have access to your Python environment so all libraries you wish to use must be vendored with your installation. That is, you need to copy all of your library code into a local folder to ship along with your app.

App Engine MapReduce API - Part 7: Writing a Custom Output Writer

Mon, 22 Dec 2014 07:07:35 +0000

View all articles in the MapReduce API Series.

The MapReduce library supports a number of default output writers. You can also write your own that implements the output writer interface. This article examines how to write a custom output writer that pushes data from the App Engine datastore to an elasticsearch cluster. A similar pattern can be followed to push the output from your MapReduce job to any number of places.

The Bash String Operators

Thu, 11 Dec 2014 19:54:12 +0000

A common task in bash programming is to manipulate portions of a string and return the result. bash provides rich support for these manipulations via string operators. The syntax is not always intuitive so I wanted to use this blog post to serve as a permanent reminder of the operators.

The string operators are signified with the ${} notation. The operations can be grouped in to a few classes. Each heading in this article describes a class of operation.

App Engine MapReduce API - Part 6: Writing a Custom Input Reader

Thu, 04 Dec 2014 22:54:12 +0000

View all articles in the MapReduce API Series.

One of the great things about the MapReduce library is the abilitiy to write a cutom InputReader to process data from any data source. In this post we will explore how to write an InputReader the leases tasks from an AppEngine pull queue by implementing the InputReader interface.

Installing MySQL-Python on OS X Yosemite

Tue, 18 Nov 2014 11:15:23 +0000

Installing the MySQL-Python package requires a few steps. In an effort to aid future Internet travellers, this post will document how to install the MySQL-Python package on OS X Yosemite.

First, install MariaDB, the drop-in replacement for MySQL. I chose MacPorts for this task, though Homebrew would work just fine. Second, update your PATH to include the mariadb executables. Third, install the Python MySQL connector.

sudo port install mariadb
PATH=/opt/local/lib/mariadb/bin:$PATH
pip install MySQL-Python

That’s it! You should be able to import MySQLdb in your Python code and interact with your MariaDB database.

Automatically Resizing a Compute Engine Disk

Tue, 11 Nov 2014 19:21:45 +0000

A recurring issue when working with Compute Engine is that newly created Instances have only 10GB of free space available. To take advantage of the full disk size you need to manually partition and resize it. This article shows one method of accomplishing this task.

A Guided Tour of Google Compute Engine

Wed, 05 Nov 2014 04:45:05 +0000

Overview

The Google Compute Engine core concepts video provides a great overview of the technology. Please take a moment to watch it. As the video shows, Compute Engine is defined by Resources, and each of these Resources is available through the Compute Engine API. You can access this API through the Google API Explorer or by installing the gcloud sdk.

Extracting the Start Sector of a Disk with fdisk

Mon, 03 Nov 2014 05:49:31 +0000

fdisk is a wonderful little utility for managing partitions. I recently had to script a series of fdisk commands for resizing a partition and needed to extract the start sector from the existing disk to do so. I ended up using this combination of grep and awk to do the job.

Packaging a Compute Engine Virtual Machine Image

Tue, 28 Oct 2014 06:03:42 +0000

Google Compute Engine allows you to make custom images from a running virtual machine. The documentation provides a sufficient example but is a little bit scattered. This article collects and presents all the steps necessary to create your own Compute Engine images that you can use as a base for virtual machines.

Using the Google Prediction API to Predict the Sentiment of a Tweet

Mon, 20 Oct 2014 06:23:04 +0000

The Google Prediction API offers the power of Google’s machine learning algorithms over a RESTful API interface. The machine learning algorithms themselves are a complete black box. As a user you upload the training data and, once it has been analyzed, start classifying new observations based on the analysis of the training data. I recently spent some time investigating how to use the API to determine the sentiment of a tweet. This article collects my thoughts on the experience and a few recommendations for future work.

Composing Asynchronous Functions With Tasklets

Sat, 27 Sep 2014 15:25:29 +0000

Asynchronous functions can provide a boon to application performance by allowing time consuming functions to operate in parallel and without blocking the main execution thread. This article explains how to use the Tasklet API to compose and execute asynchronous functions in Google App Engine.

Working From Home: A Retrospective

Thu, 18 Sep 2014 12:57:32 +0000

I’ve spent the past eight months working from home thanks to some great support from my employer, allowing me to support my wife and children and still contribute as a meaningful employee. Working from home with four small children and a loving and supportive wife has brought its fair share of both challenges and delights. This post will describe the working from home experience and the lessons I’ve learned along the way.

Converting an ndb model to a BigQuery schema

Thu, 14 Aug 2014 17:58:03 +0000

I have been working on the problem of recording changes to an ndb model. One way to accomplish this is to stream data changes to a BigQuery table corresponding to the ndb model. It would be great to do this in a generic way which gives us the problem of generating a BigQuery table given an ndb model. This article will describe one solution to this problem.

Restoring an App Engine backup into a Big Query table

Mon, 04 Aug 2014 21:18:13 +0000

An unfortunate DevOps task for any team running App Engine is restoring data from backups. One way to do this is by accessing the Google Cloud Storage URL for a given App Engine backup and importing that backup into BigQuery. This article will show you to get the Cloud Storage URL for an App Engine backup and manually perform that import.

Bypassing ndb hooks with the RawDatastoreInputReader

Tue, 29 Jul 2014 20:32:42 +0000

When doing a MapReduce operation there are times when you want to edit a set of entities without triggering the post or pre put hooks associated with those entities. On such ocassions using the raw datastore entity allows you to process the data without unwanted side effects. This article will show how to use the RawDatastoreInputReader to process datastore entities.

Generating a C# client for an App Engine Cloud Endpoints API

Tue, 22 Jul 2014 06:29:56 +0000

The Cloud Endpoints API comes packaged with endpointscfg.py to generate client libraries in JavaScript, Objective-C (for iOS) and Java (for Android). You can also generate a few additional client libraries using the Google APIs client generator. This article will show you how to use the generator to create a C# client library.

Using Basic Authentication with Google Cloud Endpoints

Wed, 16 Jul 2014 01:02:25 +0000

Cloud Endpoints provides strong integration with OAuth 2.0. If you can use this integration – do it. However, some legacy systems require supporting alternative authentication mechanisms. This article will show you how to secure an API endpoint using Basic Authentication. You can use this as a starting point for whatever authentication method you choose.

Unit Testing Cloud Endpoints

Thu, 10 Jul 2014 14:32:15 +0000

Writing unit tests for App Engine Cloud Endpoints is a fairly straight forward process. Unfortunately it is not well documented and a few gotchas exist. This article provides a template you can use to unit test Cloud Endpoints including full source code for a working example.

Creating RESTful APIs with App Engine Cloud Endpoints

Wed, 02 Jul 2014 06:14:23 +0000

App Engine Cloud Endpoints is a great way to quickly and easily create JSON API endpoints. What’s not clear is how to structure your Message code to support a RESTful create-read-update-delete (CRUD) API. This article will show the basic CRUD operations for one Resource. The results can easily be adapted to support a full REST API.

Running Multiple App Engine Modules Locally with dev_appserver.py

Tue, 17 Jun 2014 13:09:42 +0000

The recently released App Engine Modules API allows developers to compartmentalize their applications into logical units that can share state using the datastore or memcache.

Downloading directories of code from Github using the Github API

Tue, 17 Jun 2014 06:14:23 +0000

At VendAsta we frequently share libraries of code between projects. To make it easier to share this code I’ve developed a small package manager that downloads code within a directory from Github to be copied in to your current project. It’s a quick and dirty alternative to cloning an entire repository, grabbing the set of files you want and placing them in your project.

How to bypass the auto_now property option during an ndb put

Wed, 28 May 2014 05:55:48 +0000

In App Engine the auto_now option sets a property to the current date/time whenever the entity is created or updated. This is a great feature for tracking the time when an entity was last updated. However, sometimes you may want to put an entity without updating an auto_now timestamp. This article will show you how.

App Engine MapReduce API - Part 5: Using Combiners to Reduce Data Throughput

Tue, 20 May 2014 08:54:12 +0000

View all articles in the MapReduce API Series.

So far we’ve looked at using MapReduce pipelines to perform calculations over large data sets and combined multiple pipelines in succession. In this article we will look at how to reduce the amount of data transfer by using a combiner.

App Engine MapReduce API - Part 4: Combining Sequential MapReduce Jobs

Tue, 13 May 2014 10:40:38 +0000

View all articles in the MapReduce API Series.

Last time we looked at how to run a full MapReduce Pipeline to count the number of occurrences of a character within each string. In this post we will see how to chain multiple MapReduce Pipelines together to perform sequential tasks.

Installing lxml on OS X Mavericks

Wed, 07 May 2014 10:26:45 +0000

I recently tried installing lxml for use within an App Engine project on OS X Mavericks only to be hit with an error message from clang.

App Engine MapReduce API - Part 3: Programmatic MapReduce using Pipelines

Mon, 28 Apr 2014 21:51:22 +0000

View all articles in the MapReduce API Series.

In the last article we examined how to run one-off tasks that operate on a large dataset using a mapreduce.yaml configuration file. This article will take us a step further and look at how to run a MapReduce job programmatically using the App Engine Pipeline API.

App Engine MapReduce API - Part 2: Running a MapReduce Job Using mapreduce.yaml

Tue, 22 Apr 2014 06:48:36 +0000

View all articles in the MapReduce API Series.

Last time we looked at an overview of how MapReduce works. In this article we’ll be getting our hands dirty writing some code to handle the Map Stage. If you’ll recall, the Map Stage is composed of two separate components: an InputReader and a map function. We’ll look at each of these in turn.

App Engine MapReduce API - Part 1: The Basics

Tue, 15 Apr 2014 12:09:36 +0000

View all articles in the MapReduce API Series.

The first arcticle in this series provides an overview of the App Engine MapReduce API. We will give a basic overview of what MapReduce is and how it is used to do parallel and distributed processing of large datasets.

Understanding JSON Patch

Tue, 08 Apr 2014 16:12:14 +0000

The typical update cycle for an API resource is to (1) GET the representation, (2) modify it and (3) PUT back the entire representation. This can waste bandwidth and processing time for large resources. An alternative is to use the HTTP PATCH extension method to only send the differences between two resources. HTTP PATCH applies a set of changes to the document referenced by the HTTP request.

How to Version a REST API

Tue, 01 Apr 2014 14:16:18 +0000

API versioning is a fact of life. Even the most well designed API changes as new features and relationships are uncovered. Unfortunately, updating an API is seldom as simple as changing the behaviour of our existing URL endpoints on her he server. If we have existing clients we need to explicitly advertise breaking changes in a seamless way. This article explains a few methods of specifying breaking changes that offer a clear upgrade path for existing API clients.

When to Use HTTP PUT and HTTP POST

Thu, 27 Mar 2014 07:23:34 +0000

The HTTP protocol defines two methods for updating a resource – PUT and POST. Both PUT and POST are used to modify a resource and this semantic similarity can confuse API developers. This confusion has led most developers to use POST for any action which may modify the state of a resource, ignoring PUT entirely.

This article attempts to explain the semantics behind the PUT and POST methods and offers clear suggestions on when to use each method.

Stripe checkout opening in a new tab

Tue, 25 Mar 2014 07:23:45 +0000

At VendAsta we’ve been integrating with the Stripe payment system using Stripe Checkout. The experience has been completely painless and surprisingly simple. Then came a hiccup. While demoing the new functionality we found that one particular computer in the office would open the checkout modal dialog in a new browser window. Just one laptop. It was running the same version of Chrome that we were developing on. It was running the same OS as a working test machine. But the dialog would consistently open in a new browser window on just this one laptop.

How REST Constraints Affect API Design

Wed, 19 Mar 2014 14:11:48 +0000

REST was developed and formalized by analyzing the existing Web and extracting the principles that made it work. This set of principles was written down in the Fielding dissertation which lays out the set of constraints that, when enforced, will make a generic network system into a resilient network like the Web. In Chapter 5 of the dissertation Fielding outlines REST’s interface constraints.

REST is defined by four interface constraints: identification of resources; manipulation of resources using representations; self-descriptive messages; and, hypermedia as the engine of application state.

On choosing a hypermedia type for your API - HAL, JSON-LD, Collection+JSON, SIREN, Oh My!

Tue, 11 Mar 2014 15:15:15 +0000

In recent years REST has been at the forefront of modern API design. This has led to APIs with manageable URLs that respect the HTTP verbs (GET, POST, PUT and the rest), producing an intuitive model for client developers. Unfortunately, there are two problems that REST doesn’t solve alone.

Three questions that define an ideal customer

Sat, 04 Jan 2014 10:07:45 +0000

One of the first steps in selling a new product or service is finding your target market and one of the best ways of finding your target market is by defining your ideal customer. Ask yourself – out of all the people in the world who would be the most likely to buy this thing? If you can clearly answer this question you have your ideal customer and you can start a marketing campaign targetting exactly the demographic you are trying to sell to.

Let’s go through an exercise that can help to find that ideal customer by asking three simple questions.

How to get accepted to a business plan competition

Thu, 19 Dec 2013 09:09:09 +0000

I recently received the good news that my business idea was accepted for the University of Saskatchewan’s 2014 Tech Venture Challenge. The Tech Venture Challenge is a business plan competition for students and alumni where participants are judged by their finished business plan and pitch after a four month workshop program. I’m going to blog about the experience as a way to absorb the material and hopefully help someone else who may be applying in the future. This post will provide some admittedly biased advice on submitting your application to the Tech Venture Challenge.

Install node.js packages via npm with a Chef Cookbook

Thu, 06 Jun 2013 08:45:51 +0000

I wanted to set up a Vagrant instance with node.js and some specific packages pre-installed. I found a Chef cookbook to install node and after a bit of work have a cookbook that will install arbitrary node packages through npm. I based this heavily on balbeko’s chef-npm cookbook with modifications to accept a data bag list of npm packages.

Photos is the Killer Feature of Google+

Thu, 16 May 2013 16:17:18 +0000

Yesterday’s Google I/O keynote unveiled some new features in Music, Maps and Search. But to me the biggest and most important announcement was the new Google+ photo features. Full-size high-resolution photos, automatic highlights of entire albums, automatic enhancement and auto-awesome combine to make Google+ the most feature packed photo hosting service on the web. Add the ability to share pictures with anyone via e-mail (take that Facebook) and Google+ is now the best social network to host and share photos.

Apple has a Software Problem - Why I'll be Switching to Android

Tue, 30 Apr 2013 22:10:18 +0000

No one can question Apple’s dominance in hardware. The build quality and user experience of the iPod, iPhone and iPad positioned Apple as the most profitable company in the world. However, with the build quality of rival devices quickly approaching Apple quality, software will be the next battleground for consumer loyalty. And Apple has a software problem.

Creating a new file or directory in Vim using NERDTree

Fri, 19 Apr 2013 12:18:19 +0000

I’m not sure why this was so difficult to discover. For the longest time I was not sure how to create a new file using NERDTree. I finally sat down and figure out how it works.

Submitting a Unity3d Game to the Mac App Store

Tue, 09 Apr 2013 14:43:12 +0000

Submitting a Unity3d game to the Mac App Store is a somewhat painful process. This guide refers to Unity3d 3.5 but should apply to Unity 4.0 and up.

Copying from Vim to the OS X Mountain Lion clipboard

Tue, 22 Jan 2013 08:16:42 +0000

The latest version of OS X (Mountain Lion) broke compatibility with the vim and the OS clipboard. In most cases you can configure vim to use the operating system clipboard by setting clipboard=unnamed in your .vimrc. Unfortunately this setting does not work in OS X because the default version of vim was not compiled with clipboard support. You can check if your version of vim is compiled with clipboard support by typing vim –version and looking for clipboard. A prepended + means support is enabled. A prepended – means support is disabled.

Showing a local webpage in Unity3d using the Prime[31] etcetera plugin.

Thu, 15 Nov 2012 13:14:15 +0000

I’ve been working with Prime31’s Etcetera plugin for iOS development with Unity3d. There are a lot of great things in there but some of the documentation is lacking. Anyways, if you want to show a local web page with the showWebPage command it is a two step process.

Using Unity3d with Version Control

Mon, 08 Oct 2012 09:11:18 +0000

I had a tough time finding this page. The steps to get Unity set up with version control aren’t that difficult but it is one of those problems that you need to be told how to solve.

Saving canvas data to an image file with JavaScript and PHP

Wed, 27 Jul 2011 10:08:42 +0000

Saving HTML canvas element data to an image in a user friendly manner is a tricky problem. Let’s look at one way to solve it.

Using Leiningen behind a Windows proxy

Tue, 28 Jun 2011 11:15:08 +0000

I’ve been getting familiar with the Leiningen build tool for Clojure but had trouble connecting to the Clojar and Maven repositories behind a proxy.

Date.now() in IE6

Thu, 09 Jun 2011 11:10:09 +0000

I was fiddling with a JavaScript timer application and noticed a bug in IE6. I’m sure this is documented elsewhere but I couldn’t find anything with some quick searches; hence this post.

The JavaScript click event and hidden input elements

Thu, 02 Jun 2011 16:42:48 +0000

I was recently working with the HTML canvas element and wanted to attach an event to the canvas that would fire the click event of a file input element. I would then hide the input element so that the canvas element was the only way to browse for files.

Dissecting jQuery's Fade Animation

Wed, 18 May 2011 15:16:17 +0000

Fade animations are a standard tool in any jQuery developer’s toolbox. But how do they really work? Let’s create a small function that encapsulates solely the fade functionality and find out.

An Argument Against JavaScript Minification

Tue, 10 May 2011 15:11:09 +0000

Developers learn by example. This is no secret. The first advice given to new developers is to read a lot of good source code and the best advice given to experienced developers is to read a lot of good source code. Canonical texts for many languages let the source code say far more than the text. I’m thinking of text’s like Kernighan & Ritchie and Friedman & Felleisen.

How to Display HTML5 Notifications

Fri, 06 May 2011 10:10:10 +0000

Chrome recently introduced support for HTML Notifications.

Following the brief tutorial at HTML5 Rocks I was able to implement this in a matter of minutes and I couldn’t be happier with the results.

Constants in JavaScript

Wed, 20 Apr 2011 14:11:28 +0000

How are constants declared in JavaScript?

Understanding Closures in JavaScript

Wed, 19 Jan 2011 09:11:15 +0000

Closures are easy. There I said it. Invest a little bit of time, and you will say it too. Follow along with me as I attempt to explain what closures are and how they are used.

Safely remove the header from the WordPress TwentyTen theme

Tue, 18 Jan 2011 10:11:12 +0000

WordPress’ new TwentyTen theme is terrific. Well supported, highly modifiable, and with tons of widgets to get the exact layout you desire right out of the box. However, one thing I didn’t like too much was having a big header image on the page. I’m a bit of a minimalist so I wanted to trim down the theme by removing the banner image and the navigation bar.

The future of mobile development

Sat, 15 Jan 2011 09:19:21 +0000

The future of mobile development is cross-platform HTML5, JavaScript, and CSS3. Let me explain. I’ve been working on a couple Windows Phone 7 applications to accompany my first release, FaceArt, in the Marketplace. As I do more research and development with the mobile platform I keep looking for ways to increase the reach of my apps. The most obvious is to release Android and iOS versions but I have a few hurdles to clear first, the biggest being lack of time. I do all development as a moonlighting gig while I work full-time and I’m already struggling to find extra hours during the week to finish my first three applications for one platform. How am I going to write and maintain three separate codebases for each app for the major mobile platforms while still keeping my employer happy during the work week? The solution is cross-platform libraries targeting mobile and web apps. PhoneGap, AirPlay, and DragonFire SDK are a few notable products designed for just this problem. The most notable, and most intriguing for me, is PhoneGap. I first noticed PhoneGap through an article on ArsTechnica. This open-source solution wraps apps designed with HTML5, JavaScript, and CSS in a container suitable for the respective app stores. Why is this exciting? You can design an application for the web and get the mobile app for free (or minimal) time investment. This is as close to the write once, run anywhere ideal that we will get for mobile phones and as the tools improve the experience is only going to get better for developers. I personally can’t wait to see what the future holds for this product. What do you think?

A cheap home server

Tue, 11 Jan 2011 06:55:12 +0000

In order to have a home server you need the server. That is, you need the hardware. You could probably find all sorts of information comparing performance, power consumption, and cost for an assortment of different parts (check tomshardware.com or do some intense [Googling][2]). Or, you can trust that I’ve done my research and go with the same setup as me.

And the winner is - Google Chrome!

Thu, 06 Jan 2011 15:23:34 +0000

Google gets it.

How to install the real-time kernel in Ubuntu

Tue, 19 Oct 2010 15:09:18 +0000

To use Ubuntu as an audio production server you need the real-time kernel. This allows applications to have some guarantee of the maximum response time of any task. High priority tasks are given the CPU within a fixed minimum amount of time allowing for processor intensive tasks to actually be completed. Follow along to see how to install the real-time kernel yourself. A vanilla install of most Linux distributions does not enable the real-time kernel, but it is easy enough to install.

How to get Pulse Audio to recognize your Delta 44 (and other ICE1712 cards)

Tue, 28 Sep 2010 14:23:34 +0000

I bought a used Delta 44 soundcard with the intention of recording my guitar playing. Pairing this with Rockit 5 powered monitors, a Mackie 802-VLZ3 mixer and the classic Shure SM57 microphone made for a good quality, inexpensive home studio. Using the PCI-based Delta 44 meant that any old computer would work and my idea was to use vanilla Ubuntu and install the Ardour digital audio workstation to push costs even further down. So far so good. Now the only issue is getting everything up and running. Ubuntu is a fairly mature distribution; you can expect a certain level of quality with each release. Unfortunately, this has not been the case with PulseAudio. I won’t go into details; suffice it to say it had a tumultuous upbringing and many of the kinks have since been worked out. Anyways, I quickly discovered that PulseAudio does not recognize the Delta 44. Don’t worry, this is a known problem and a workaround exists. Finding the workaround, however, did take some time.

Readability by Arc90

Sat, 04 Sep 2010 13:13:13 +0000

According to Wikipedia, readability is defined as reading ease, especially as it results from a writing style. Only experience, practice, and hard work can improve a person’s writing style. Let’s increase readability in a different manner: with typography.

Share multiple mt-daap libraries

Tue, 03 Aug 2010 18:12:34 +0000

I recently moved all of our household music to a shared network drive and was looking for a solution to stream these libraries as distinct entities; I wanted to keep my wife’s library separate mostly so I could keep all of my painstakingly catalouged music organized exactly how I like it. I was already using mt-daapd, now known as the Firefly Media Server, to stream my own library from my Linux server. Unfortunately, it doesn’t support streaming two libraries from one program instance. The solution to this is to run two copies of mt-daapd and configure them to play nice with each other. Don’t worry, it’s not quite as difficult as it sounds. The first thing you’ll need is to have a separate configuration file for the second daap instance. The easiest way to do this is to copy the files from an existing installation.

Mounting SAMBA shares from the command line

Wed, 28 Jul 2010 18:12:37 +0000

I recently started using Xubuntu to see if the proclaimed speed differences actually made a difference in productivity. Unfortunately, the Thunar file manager does not automatically recognize network drives so I needed to manually mount SAMBA shares from the command line. In my searches I stumbled across this thread giving the exact solution I used. Hopefully this helps someone else who is having this same problem.

How to forward root users mail to an external address

Tue, 01 Jun 2010 14:12:32 +0000

I recently set up a RAID array wanted to keep notified of any errors that may occur. By default Ubuntu Server sends mail to the root user whenever an error occurs but logging in as root to check mail every so often didn’t seem very convenient. There had to be a better way. The best information that I found came from the Ubuntu community forums. Here I’ll expand on that discussion, hopefully helping other people who are trying to do the same thing. The traditional way to forward mail is to create a .forward file in your home directory, entering the addresses that you would like to forward mail to.

How to monitor a RAID array in Ubuntu server

Fri, 28 May 2010 02:15:45 +0000

I’ve been searching for a way to reliably monitor a RAID array. I found a few resources and decided to compile them in one post. If you are running Ubuntu Server skip to the bottom for some good news.

AI Ethics

Mon, 01 Jan 0001 00:00:00 +0000

This blog is written by me, Kevin Sookocheff, without AI assistance. I will not publish anything that takes you longer to read than it took me to write.

The act of writing does many things.

It forces you to slow down, focus your attention, and think deeply. It uncovers gaps in your thinking. It refines and clarifies your position. And you almost always learn and discover something new in the process.