Last Ent's Thoughts (Posts about software design)

FP for Sceptics: Intuitive guide to map/flatmap

Ent — Thu, 19 Nov 2020 18:03:25 GMT

Backbone of Functional Programming

map & flatmap form the backbone of Functional Progamming. It is very important be comfortable with these two concepts and this guide will help you develop an intuition for them.

This guide is language agnostic but I expect you to be familiar with basic programming concepts like functions, types, data type/objects and list.

Nomenclature

Let me introduce you to some basic terms we will be using to talk about map/flatmap.

Types are data constructs and they can be Basic Types like Int, String etc.
Container is a special type which contains another type. For example a List of Ints.
Function is a function whose input is of Type 1 and output is of Type 2. Type 1 & Type 2 can be same type.

Visualize

Though I have defined three terms it will be easier to think about them visually.

`Basic types` (Int, String etc) will be represented by shapes

Dependency Mock Server & Black Friday Preparation

Ent — Sat, 19 Sep 2020 21:34:47 GMT

Last year while preparing for Black Friday our team had an interesting challenge:

Some of our downstream services¹ had proper setup to provide environments/APIs to load test.

This meant will have to configure our systems based on hopeful estimates based on last minute estimates and until then, we would could only sit idle. This wasn't appealing for obvious reasons of doing a hackjob and having a firefighting mode during Black Friday/Cyber Week.

Proposed Solution: Dependency Mock Server

The solution I came up with and which we used was to have a Mock Server that served endpoints similar to our dependencies and return dynamic responses based on request payload.

Visual guide to polling in Functional Programming (Scala)

Ent — Sun, 26 Jul 2020 15:55:41 GMT

In this post, let's look at how to poll a system using a Stream.

To make it easier/interesting, I will explain it using a visual approach.

Let's use the following problem statement.

We have API for a queue² that can be queried using pollFn function.
We need to process data returned by queue using process function.
There may or may not be data at the time of querying.

FP for Sceptics: Option Type in Practice

Ent — Mon, 29 Jun 2020 16:00:00 GMT

In previous post we defined FP & error handling

Functional Programming (FP) is based around mathematical concepts like Type Theory - We define our system in terms of ADTs, data flow & functions.

FP promotes using types for error handling

Option

Either

Monad

etc.

Previous post also explained Option type and how it works.

ADTs in Practice took a practical system¹ and designed ADTs for it.

In this post, we will reuse the same system but try to figure out where Option type makes most sense to use.

FP for Sceptics: Introduction to Option Type

Ent — Sun, 31 May 2020 22:38:34 GMT

Functional Programming (FP) is based around mathematical concepts like Type Theory - We define our system in terms of ADTs, data flow & functions¹.

We first implement "Happy Path" and then implement handlers for "Unhappy Path" (error handling). In ADTs in Practice we used "Exceptions" (IO.raiseError) for error handling.

However FP promotes using types for error handling, such as:

Option
Either
Monad
etc.

In this post we will start by looking at the simplest of these:

Option type denotes presence (Some(value)) or absence (None) of a value.

FP for Sceptics: ADTs in Practice

Ent — Sun, 24 May 2020 15:50:02 GMT

In previous post we defined ADTs as

Algebraic Data Types (or ADTs) model the flow of a program (or a system) in terms of data & functions that describe the complete behaviour and states the data can go through.

In this post, we will work through defining ADTs for an API service.

API service will return User's Information by:

Extracting user id & password from the request
Checks them against an authorization service
Retrieves User's Information from database
Returns User Information in response

FP for Sceptics: Introduction to ADTs (Algebraic Data Types)

Ent — Mon, 13 Apr 2020 22:31:05 GMT

Algebraic Data Types (or ADTs) model the flow of a program (or a system) in terms of data & functions that describe the complete behaviour and states the data can go through.

Let's take an example to grok the concept better.

Example: Area of a rectangle

Calculate the area of a rectangle from a list of positive integers

Here's a possible algorithm:

Take a list of integers (positive & negative)
Filter for positive integers ie., remove negative integers
Create pairs from the filtered list
Apply equation for area of rectangle

Elegance of Monadic Composition

Ent — Sat, 02 Nov 2019 03:19:08 GMT

Functional programming has many interesting concepts but it can be hard to find practical applications for it in everyday work. In this post, I will explain how Monadic Composition can be used write elegant and easy to understand code.

Consider an API Donatron that accepts donations. The API's algorithm is as follows:

Accepts donations as list of strings
Should have a few valid integer donations
- Else goto 6. Response: No Valid Ints
Should have a few donations of value 10 or above
- Else goto 6. Response: No Acceptable Donations Found
Valid donations to external service should succeed
- Else RuntimeException
Log all accepted submissions
Log Response
Return Response

End goal is to be able to execute Donatron.donate function and get correct response.

Type Driven Development

Ent — Sun, 08 Sep 2019 14:11:55 GMT

Introduction

In our project workflow, we break down features to implement into tickets and developers pick them off one by one; Pretty standard & typical Agile/Kanban workflow. However while working on a feature recently, we came across on an interesting problem where our standard workflow didn't work out. Rather than trying to explain it in vague terms, I am going to start with a story.

TLDR

In case you don't want to dive in just yet, here is the idea we will cover in this post.

Think about the behaviour of your program in terms of data types & functions signatures. Next step is to prove or derive a function that composes all of the types & signatures to implement the feature. Then carry on to implement each of the individual functions with the guarantee that all functions will compose together.