## Representing Pairs and Lists in Lambda Calculus

Posted on September 7, 2018
•
lambda calculus
fp

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).

[Read More]
## Typed Lambda Calculus

Posted on August 21, 2018
•
lambda calculus
fp

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.

[Read More]
## A Guide to the Kubernetes Networking Model

Posted on July 11, 2018
•
kubernetes
networking

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.

[Read More]
## Infrastructure in an Age of Commodities

Posted on June 19, 2018
•
infrastructure
architecture

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.

[Read More]
## Recursive Lambda Functions the Y-Combinator

Posted on June 11, 2018
•
lambda calculus
fp

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:

[Read More]
## Simplifying Lambda Syntax

Posted on May 25, 2018
•
lambda calculus
fp

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

[Read More]
## Introducing Lambda Calculus

Posted on April 27, 2018
•
lambda calculus
fp

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.

[Read More]
## A Principled Approach to Architecture

Posted on March 23, 2018
•
architecture
management

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.

[Read More]
## Range, Domain, and Codomain

Posted on March 9, 2018
•
fp

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.

[Read More]
## Functional Microservices

Posted on March 5, 2018
•
architecture
process

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.

[Read More]