Last Ent's Thoughts (Posts about programming)

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

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.

Elements of Coding Style

Ent — Sun, 15 Sep 2019 09:04:43 GMT

Rules of Software Engineering

There are three important rules in Software Engineering.

Rule 1: Easy to understand. Anyone should be able to pick up the code and start working on it.
Rule 2: Easy to debug. If the code breaks, it should be easy to quickly investigate & identify where is the issue.
Rule 3: Shipping is the most important feature. No matter how correct or elegant your code is, if you can't ship working code on time then why bother?

Having said that, Rule 3 should rarely be in opposition to Rule 1 & 2. If you have to veto Rule 1 & 2 to ship your feature, then something's horribly wrong in your code & process. Complexity in code is a given and it is an engineer's responsibility to figure out how best to contain the damage and stop it from affecting the rest of the system.

Less elegant yet easy to understand & easier to debug should be the minimum expectation from all code shipped.

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.

Cats Effect's IO

Ent — Mon, 12 Aug 2019 18:44:38 GMT

Cats Effect's Fibers/IOs run on a thread pool created over VM. They are essentially Green Threads that are created over the thread pool. Unlike async frameworks, IO.flatmaps does not include _asynchronous boundary. This means that essentially all of nested flatmaps are run within a single fiber. IO has mechanism to introduce asynchronous boundary but this has to be done manually by the developer via IO.shift. Operations such as race, parMapN or parTraverse inherently introduce asynchronous boundary.

~ 14th May, 22:11