DEV Community: Dave Howson

An Introduction to Functional Programming

Dave Howson — Sat, 08 May 2021 07:43:03 +0000

Functional Programming has been around for many decades but languages like JavaScript have given it a new found popularity in the recent years due to it its simplicity and straightforwardness. Functional Programming is a Declarative Programming Paradigm where we tell a program what it needs to accomplish rather than telling it how it needs to accomplish this. For example, consider the following scenario using simple JavaScript.

Say we have an array of numbers [1, 2, 3, 4] and we need to add 1 to each of the numbers in this array. We can achieve this Imperatively or Declaratively.

The Imperative approach would be to first create a new array, run a loop through all the numbers in our initial array, add 1 to each of the numbers and push it to our new array.

const arr = [1,2,3,4]
const newArr = []

for (let x = 0; x < arr.length; x++) {
    newArr.push(arr[x] + 1)
}

In the Imperative approach, we tell the JavaScript compiler exactly what needs to be done using low level constructs such as loops and assignments.

However, the Declarative approach would be to think about what our end result would be and achieve this without the use of conditionals and loops.

const arr = [1,2,3,4]
const newArr = arr.map(x => x + 1);

The Declarative approach utilizes a method built into the JavaScript language to easily achieve what we want to without having to manually loop through the array.

Declarative Programming is much more cleaner than its Imperative counterpart in most cases and it leads to clean and minimal code.

Built on the concepts of Declarative Programming, Functional Programming is a paradigm where we create programs by applying and combining multiple functions together. In Functional Programming, a value can be converted into another value by running it through a set of functions.

const calculateValue = (val) => {
    const valByTen = multiplyByTen(val)
    const valPlusTwenty = addTwenty(valByTen)
    return valPlusTwenty;
}

Above is a simple example of how a value can change as it is passed through multiple functions. Two important things to note here is that regardless of how many times you run this function, as long as the input value remains the same, the output value will always be the same as well. Secondly, the input value never changes throughout the function. Instead of changing it, we create a new value based on the input and return that as the result of the function.

Concepts of Functional Programming

In order to better understand Functional Programming, we must first understand the concepts and ideas behind Functional Programming.

First Class Functions

Languages such as JavaScript treat functions as First Class Citizens. This means that functions can be used anywhere that a regular entity (strings, numbers, etc..) are used. Functions can be stored in variables. They can be passed as parameters into other functions. Functions can be returned as a result of another function and they can also be included in data structures such as arrays. In order to write functional programming code, the language should support functions as first class citizens.

Another concept here is Higher Order Functions. When functions are treated as first class citizens, they can be passed as parameters into other functions. This helps us create complex programs by composing a set of simple functions.

Immutability

Immutability is the inability of an entity to be changed. In Functional Programming, we use Immutability to ensure that entities such as variables and functions always remain the same throughout the lifecycle of the programs execution. This concept helps us create predictable and maintainable code as we know that once a value is initialized, it will never be changed.

const name = 'john'

const upper = (value) => {
    return value.toUpperCase()
}

const newName = upper(name)

In the above example, we assign the string john to a variable called name. When these lines of code are executed, the variable will be initialized with the given string and once done so, it can never be altered again. If we need to change the casing of this string to an upper case, we have to create a new variable called newName and pass the name as the parameter to the upper function which will create a new variable, convert it to upper case and return the result so that it can be assigned to newName. It is important to note here that name was never altered and thus, immutability was maintained. In the lack of immutability, code becomes harder to manage as we do not know which function changed the original value and that leads to unpredictable results.

Pure Functions

Functional Programming utilizes the concept of Pure Functions where given the same input to a function, it will always return the same output.

const multiplyByTen = (val) => {
    return val * 10
}

The above function will always multiply a given input by 10 and respond with the new value. If we run this function with the same input, it will always return the same output. This concept is important because as our program and the functions in it grow in size and complexity, we must always maintain pure functions that return predictable outputs. In order to implement Pure Functions, we must always make sure that our functions have No Side Effects. A Side Effect is when a function alters a value outside of its local scope. We can make the above example an impure function by introducing a value outside of its scope.

let val = 10;
const multiplyByTen = () => {
    val = val * 10
}

Since an outside value is altered by this function, we cannot ensure that its output will always be the same, thus making it an impure function.

Another important concept here is that of Referential Transparency. This means that the value of a variable never changes once defined. When we define a value and pass it as a parameter to a function, in a pure function, this initial value will never be changed. But in impure functions, like the one above, the initially declared value will change based on the execution of the function.

A pure function is predictable and its data will always flow through the same steps upon execution.

Functional Programming prevents the use of a shared state in programs because using such a state among functions would make them impure and unpredictable. However, there are workarounds for this where we can use a shared state which is the result of a set of data passed through a set of functions. Redux is a great implementation of this where we use a shared state in a functional way. You can read more about that here.

Using the above mentioned core concepts, Functional Programming helps developers create modular and predictable programs that are the result of composing multiple pure functions together. In Functional Programming, the output of the program is purely determined by its inputs and the functions that these inputs flow through.

Since this is an Declarative Programming paradigm, declarative concepts are applied in Functional Programming as well. For example, say that we are building an e-commerce platform and that we wrote a function to calculate discount based on the price and the type of item provided. Once written, we can use this function in the store section where we display products and their discounted prices. But we can also use this confidently in the cart section as well, where similarly, we need to show a product and its discounted price. In such a scenario, once we create the discount calculation function, we do not have to worry about its implementation any more. We can reuse this function in both the store and the cart because at that point, we know that since this is a pure function, given the same input, it will always return the desired and predictable output thereby allowing us to disregard its implementation logic (how the discount is calculated) and focus on where we can use it.

Advantages of Functional Programming

Functional Programming has been around for decades and its concepts have been used in Mathematics for much longer than that with good reason. Following are some of the advantages that programmers can gain from using Functional Programming.

Simple

Functional Programming helps developers solve complex problems in a modular and simple approach. Instead of writing large and complicated solutions to solve a problem, we can break down a problem to more manageable parts and write functions to solve each of these problems individually. The final solution would be the result of all these functions working together to solve this complex problem using a modular approach.
Easy to understand

Functional code is easier to understand because we only have to comprehend what is going on in a single function at a time. Even a program that solves a complicated problem can easily be understood by a programmer because this problem will be broken down to separate functions and to understand a single function, all you have to do is to identify the input parameters and figure out what this specific function is doing to alter the values that were passed into it. It also helps that these functions are not affected by anything other than the parameters passed into them.
Maintainable

A large codebase can easily be maintained when all it consists of are individual functions. We can easily refactor any of these individual functions as long as we maintain its integrity and respect the inputs and outputs of it.
Easy to debug

Simple, understandable and maintainable code is simply easier to debug. We do not have to think about the entire application and how it handles a complex flow of data in order to debug an issue in a single function. A function is given a responsibility to provide a predictable output and if it does not do this, then this is a problematic function which should be fixed. Doing so would not break other functions as the logic inside of a function does not affect these other functions. Only the inputs and outputs do.
Testable

Functional code is very easy to test as these functions are inherently self contained. Once given some input, it should always return the expected output. It is very easy to write test cases for such functions and because of this, a functional codebase can be a highly tested and confident codebase.

Disadvantages of Functional Programming

As all things in life, Functional Programming too has its weaknesses that can be better solved using other paradigms such as Object Oriented Programming.

Complicated in some scenarios

Simplicity is an advantage of Functional Programming, but in some scenarios, following the strict guidelines of Functional Programming can make simple solutions overly complicated.
Composing functions can be troublesome

Functional composition, where we use the result of one function as the input of another function, thereby composing a large number of functions together can sometimes be harder to maintain. This depends on the problem domain and the way of approaching a solution. But just because Functional Programming can lead to cleaner code does not mean that it always leads to cleaner code.
Harder to comprehend

Good Functional Programming is a result of good functional thinking. In order to breakdown a complex function to a set of simple functions, one must have to do a lot of thinking and planning. Programmers should also train themselves to think functionally which is not always an easy thing to do as our brains do not comprehend solutions that way.
Refactors are unavoidable

Functional Programming depends heavily on the concept of reusable functions. However, in most cases, we simply cannot predict all of the potentially reusable functions that we will create, and in the long run, as we begin to better understand the solution we are building and as some of the requirements of our solution change, it will become inevitable that we will have to run across functions which will require refactoring.

With the advancements of the development ecosphere, everyday we tend to move more and more closer to simple and declarative solutions. Developers are moving away from the mentality of needing to custom-build everything from scratch and instead are starting to see the amazing benefits of reusing code and libraries across solutions. Programming languages such as JavaScript keep evolving and adding new features to it so that developers can focus more on the problems they need to solve rather than having to worry about the implementation details of the methods and tools they use. This landscape is breathing new life into the wonderful paradigm that is Functional Programming. For me personally, clean and reusable code is everything. I thank the day I decided to learn Functional Programming and I have loved it ever since. I hope you will too.

#happycoding

An Introduction to WSL

Dave Howson — Sat, 22 Aug 2020 06:28:07 +0000

What is WSL?

Introduced with the Anniversary Update in August 2016, the Windows Subsystem for Linux is a feature that lets you work seamlessly on a Linux environment inside of Microsoft Windows.
WSL is a compatibility layer that runs on top of a Windows environment letting you experience the best of both worlds.
Unix based Systems like Linux and macOS have always been the go-to Operating Systems for Web Developers and Open Source project contributors due to their unparalleled support for development tools and their similarity to production environments. Microsoft Windows has improved its developer experience tremendously over the years, especially with the introduction of tools like PowerShell and Hypervisor technologies, but many developers still prefer Linux over Microsoft Windows when it comes to their development platform.
However, WSL is here to change that. When combined with the convenience of Windows and the functionality of Linux, WSL becomes the obvious platform of choice for many developers especially in the field of Web Application Development.

WSL1 vs WSL2

WSL comes in two versions and they have significantly different architectures under the hood. In order to understand the architecture of WSL, we must first understand the architecture of the Linux Operating System. A machine that runs on Linux can basically be divided into four sections.

Hardware - This is the physical machine
Kernel - This is the core of the Linux operating system. It facilitates the communication between software and hardware.
Shell - This is the interface that takes input from the user and communicates this with the kernel
Applications and Utilities

WSL1 runs Linux compatible applications and utilities on top of a Linux Shell (e.g. Bash). In a Linux Operating System, the Linux Shell communicates with the Linux Kernel in order to process and relay system calls sent from applications and user commands. However, in WSL1, a Linux Kernel does not exist. Instead, system calls from the Shell are translated to calls that are compatible with the Windows NT Kernel that ships with Microsoft Windows.

Processes in an operating system execute in one of two modes. Lower level processes that need direct access to the Kernel and hardware devices are executed in the Kernel Mode while higher level processes are executed in the User Mode. When a higher level process makes a lower level system call, this is relayed to a process running in the Kernel Mode which handles this call and replies accordingly. In WSL1, Unmodified Linux Binaries run inside processes known as Pico Processes in the User Mode. These Pico Processes run in isolated environments and they do not have any direct contact with the outside environment. System calls sent out by Pico Processes are handled by Pico Drivers. Due to the isolated architecture of these processes, they are able to run pure Linux binaries without having to worry about the environment in which they are executed in.
WSL1 consists of two Pico drivers - LXCore & LXSS. All system calls sent out by Pico Processes are handled by these two drivers. These drivers, running in the Kernel Mode, translate Linux system calls to Windows system calls that can be understood by the Windows NT Kernel. This allows pure Linux binaries running on top of a WSL environment to function as if they are functioning in a pure Linux environment without having to bother about the underlying Windows Operating System.

This translation based architecture was a good solution to implement interoperability between Windows and Linux. But translation takes time and some Linux calls cannot be translated perfectly to Windows calls. Instead, the WSL team came up with a better solution in WSL2.

WSL2 boots up a Linux Kernel inside a highly optimized Virtual Machine which uses the Hyper-V architecture of Windows. WSL2 provides all the features of WSL1 along with some major improvements such as

Full System Call Compatibility
Faster IO Performance
Smaller Memory Footprint

Since WSL2 is based on virtualization via the Hyper-V architecture, it is able to provide users with a complete Linux Kernel. This Kernel runs separately alongside the NT Kernel and all hardware calls are handled by the underlying Hypervisor.

The Highly Optimized Utility VM that WSL2 runs on top of gives it the ability to boot up extremely faster than a traditional VM. Similar to WSL1, WSL2 can easily access the Windows File system and other IO components such as external devices and network connectivity. In fact, the modern architecture of WSL2 ensures that it is much faster than WSL1 when it comes to accessing files and networks.
Since WSL2 has access to a fully fledged Linux Kernel, it provides users with 100% system call compatibility. This means that WSL users can do anything that native Linux users can do with their Kernel.
The inclusion of a Linux Kernel also means that WSL2 can receive updates much more efficiently than WSL1. Previously, in WSL1, when a new feature or an update is deployed to the Linux Kernel, the WSL team had a lot of work to do in the translation layer before this feature was deployed to WSL users. However, in WSL2, new Linux Kernel features and updates can simply be deployed via Windows updates since there is no translation layer, giving WSL users access to the latest and greatest Linux features in an instant.

Why use WSL?

WSL is the perfect combination for Developers of Web and Open Source Projects who can benefit from the combined power of Windows and Linux. Since most web servers run on Linux environments, developers can develop their applications on production-like environments while enjoying the accessibility, stability and modernness of Windows. WSL allows developers to run Linux specific tools in a Windows environment without having to go through the hassle of running a Virtual Machine. Unlike traditional VM's, WSL is fast, efficient and needs no initial configuration to get it up and running. WSL provides developers with an advanced, state-of-the-art Linux experience on Windows without any of the complexity. Developers do not have to resort to dual boot or VM's anymore in order to experience the best of both worlds, making WSL the perfect choice for them.

Linux has always stood out over the rest of the Operating Systems out their because of its impressive list of distributions. WSL supports almost all of the popular Linux distros and they can be easily downloaded via the Microsoft Store. WSL users can install multiple Linux distros and seamlessly switch between them when needed.

The WSL team has gone above and beyond to make WSL a worthwhile option for developers. Unlike in VM's where the virtualized OS is isolated from the environment around it, WSL has full access to the underlying systems network and files, making it very easy for developers to work on the same projects in both Windows and Linux environments. Microsoft has also released plugins for tools such as VSCode that help developers access projects inside WSL via the VSCode UI, which simplifies cross platform development workflows. Developers can simply open VSCode inside Windows, open up their projects inside WSL and start coding right away. No hassle, no configuration and no stress!

WSL props up Microsoft Windows as a serious candidate in the developer Operating System market. With an ambitious and dedicated team behind the development of WSL, Microsoft has opened up new possibilities in the world of remote development and we couldn't be more happier about this.

For more information about WSL and how to get started on it, visit the Official WSL Docs.