DEV Community: Mohamed Dahir

My adventures in ML Land

Mohamed Dahir — Sun, 20 Mar 2022 15:11:06 +0000

I thought it might be interesting to document my journey of learning the ML family of languages. I will try to list the resources I used in chronological order (mostly) in the hopes that it might help someone else.

Discovering and Learning F#

My first exposure to F# was through these two talks by Scott Wlaschin

I am not sure how I got interested in computation expressions but I do remember at some point thinking of ways to use it for implementing a react-hooks clone. After I started reading fsharpforfunandprofit's Computation expression series, I realized that let-expressions were a key to understanding the concept. A quick google search led to https://www2.lib.uchicago.edu/keith/ocaml-class/definitions.html

Later, I needed to write tokenizer + lexer as a part of an assignment in Nand2Tetris part two. Conveniently, this was when I stumbled on posts about using F# for writing parsers.

Things I didn't like about F#

Use of XML in fsproj
Optional and named arguments not being available to normal functions
Not CLI friendly as other languages. dotnet-cli is attempting to fill this gap but it is not quite there yet.
Cannot create a native executable that can be easily distributed.

Moving to OCaml

Because F# was originally inspired by OCaml which doesn't have any of the pet peeves I had with F#, I decided I should give OCaml a try

I wanted to write an HTTPie clone in OCaml. To do that, I started reading Real World OCaml to better familiarize myself with the language.

Real World OCaml uses Base to replace OCaml's stdlib. I am not very fond of Base since it deviates from the standard convention of passing functions before values in HOC. To fix the ordering, one has to use labels:

open Base

[1;2;3;4] |> List.map ~f:(fun x -> x * 2)

Fortunately, there is Containers which gets the argument ordering right.

open Containers

[1;2;3;4] |> List.map (fun x -> x * 2)

To write OCaml code, I sat up Neovim by following this guide. For my repl needs, I used Utop. Whenever I needed to insert multiple lines, I used Utop's $editor integration which could be opened by C-x C-e.

There is a lot to be desired about OCaml tooling, but I am really excited about opam-tools and duniverse.

Haskell

While searching for OCaml twitch streams, I stumbled on tsoding channel which does mostly Haskell and occasionally some OCaml.

Later, I watched some videos about Elm which counterintuitively made me fall in love with Haskell.

More concise syntax for lambda declaration
Types taking their own line
Infix operators with customizable associativity and precedence.
Can be compiled into a single binary.
Type classes.

One thing I missed in Haskell was F#'s pipeline operator. Fortunately, It can be easily defined.

λ> import Data.Function ((&))
λ> (|>) = (&)
λ> (<|) = ($)
λ> [1..10] |> filter even |> map (\x -> x * 2)

Everything as an expression

Mohamed Dahir — Sun, 20 Mar 2022 15:06:29 +0000

In my journey of learning F#, I have come across the concept of "everything is an expression" which was an eye-opening experience for me. Now before I go into more details, let's just clear up the difference between an expression and a statement.

I like to think of an expression as anything that evaluates to a value. This includes arithmetic operations, ternary operators, function results, etc.

// arithmetic expression that evalues to 36
5 * 6

// function call that evalues to 120
factorial(5)

// ternary operator that evalues to 9
isEven(11) ? 8 : 9

Notice how all of these evaluate to a value that could be stored in a variable. Now let's look at some examples of a statement.

// assignment
let b = 7

// branching
if (x % 7) {
    // some code goes here
} else {
    // some code goes here
}

// loops
while (true) { /* some code */ }
for (let i = 0; i < 10; i++) { /* some code */ }

let's say you are designing a new language and you don't like this arbitrary distinction between expressions and statements, what can we do to fix this without making the language unusable?

We can start by combining if-statements and ternary expressions into one by making if-statements return the last value in their bodies.

let a = if (b > 10) {
    /* some code */
    5
} else {
    /* some code */
    3
}

You can refer to Binding and continuations in ML for why blocks expressions evaluate to the last value in their bodies.

What about while/for loops? their functionality can be easily replicated by recursion so let's get rid of them. For example, the following:

let i = 0;
while (i < 10) {
    print("hello world")
    i++
}

could be converted to use recursion like this:

let loop = (i, end) => {
    if (i < end) {
        print("hello world")
        loop(i + 1, end)
    }
}

loop(0, 10)

This leaves us with let-statements. in ML languages, we have let-in expressions which is inspired by Mathematics

(* this is the same as (5 * 5) + 1 *)
let x = 5 in (x * x) + 1

Notice that in our previous example, we are not assigning to a variable. Instead, we say that x will stand for the value 5 in the expression after the in keyword.

Since let-statements take expression after the in keyword and since they are themselves expressions, we can do something like this:

let x = 5 in (let y = 6 in x + y)

if we remove the parenthesis and do a little bit of formatting, we would end up with something like this:

let x = 5 in
let y = 6 in
x + y

So why all of this is important? Well, I think grokking the concept "everything as an expression" is vital to understanding why pure functional programming languages tend to avoid mutations and side effects.

Binding and continuations in ML

Mohamed Dahir — Sun, 20 Mar 2022 14:36:28 +0000

If you have ever worked with Rust code before, you might have come across code like this

let a = {
  let x = 5;
  let y = 4;
  let x = 7;
  x + y
}

Considering your past experience with C-based language, several questions might spring to mind:

Why is it legal to define the same variable multiple times?
Why do blocks evaluate to the last expression in their bodies?

To get answers and more, It helps to look at a distant cousin to Rust.

Enter OCaml

NB: You can refer to https://learnxinyminutes.com/docs/ocaml/ for a quick crash course on OCaml's syntax

The same code in OCaml would be written like this:

let a =
  let x = 5 in
  let y = 4 in
  let x = 7 in
  x + y

Which could be viewed as syntactic sugar for the following:

(* bind is a Higher-order function that takes a value and
 * a function, and returns the result of applying that value
 * to the function
 *)
let bind x fn = fn x;;

bind 5 (fun x ->
  bind 6 (fun y ->
    bind 7 (fun x ->
      x + y
    )
  )
);;

(* Same code but without indentation.
 * Notice how bind has replaced the assignment operator.
 *)
bind 5 (fun x ->
bind 6 (fun y ->
bind 7 (fun x ->
x + y)));;

Because each line in our first OCaml snippet corresponds to a nested function in our second snippet, we can see why it is legal to define the same variables multiple times. It also shows why blocks are just expressions that evaluate to the last value in their bodies.

Killing all birds with one stone

Replacing the assignment operator with a customizable bind function is a powerful abstraction that lets us do all sorts of things that would otherwise have taken years to be implemented in the core language, including Rust's try operator and async/await syntax.

While I won't bore you with all the details of how this is done, I will leave you with some resources if you're interested in how deep the rabbit hole goes.

CLI tools I use

Mohamed Dahir — Thu, 10 Sep 2020 12:57:19 +0000

I recently reinstalled Ubuntu on my Windows 10 machine using WSL2. But before I did that, I noted down the tools I frequently use. In the hopes this might be helpful, here are the tools in no particular order.

1. Neovim

Although VScode + VScodeVim is my daily editor, I am still somewhat attached to it.

2. fzf

I mostly use this to search through my commands history

3. ngrok

This is useful as a proxy both inspecting HTTP requests/responses and for temporarily exposing your local-server to the internet.

4. qrcp

Whenever I need to send files between my phone and computer, this is the tool I reach if I don't have a USB nearby.

5. zsh + oh-my-zsh

oh-my-zsh is packed with features that I keep discovering every day. For example, if you type a letter and press up, you will only get the entries that begin with that prefix. Not to mention the awsome git integration and preinstalled prompt themes.

6. HTTPie

A great alternative to Postman or curl + jq.

7. fx

A modern terminal JSON viewer with support for collapsing nodes.

8. Z

I use this tool whenever I need to quickly navigate between frequently visited folders. This comes pre-installed with oh-my-zsh and just needs to be enabled in its plugins section.

9. Others that I don't use so often

How to Setup a minimal F# Project

Mohamed Dahir — Tue, 14 Jul 2020 23:21:51 +0000

In a previous post, I highlighted how to use F# without setting up a .NET project. This time, we will look into the process of setting up a minimal F# project, adding unit-tests, and finally publishing it.

Let's start by scaffolding an F# project using dotnet new command

dotnet new console -lang "F#" -o hello-world

You should see a new folder named hello-world in the directory where you just ran the command

hello-world
├── obj
├── hello-world.fsproj
└── Program.fs

let's take a quick look at Program.fs

// Learn more about F# at http://docs.microsoft.com/dotnet/fsharp

open System

// Define a function to construct a message to print
let from whom =
    sprintf "from %s" whom

[<EntryPoint>]
let main argv =
    let message = from "F#" // Call the function
    printfn "Hello world %s" message
    0 // return an integer exit code

To run our project, we use dotnet run which will invoke main function in Program.fs

dotnet run
# Hello world from F#

Importing files

To acquaint ourselves with how files and modules work in F#, let's create a second file.

// Utils.fs

module Utils

let permute list =
  let rec inserts e = function
    | [] -> [[e]]
    | x::xs as list -> (e::list)::[for xs' in inserts e xs -> x::xs']

  match List.length list with
  | 0 -> []
  | _ -> List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

Update Program.fs to use our Utils module

[<EntryPoint>]
let main argv =
    let input = argv.[0] |> List.ofSeq

    let listToStr = List.toArray >> System.String

    input
    |> Utils.permute 
    |> List.iter (listToStr >> printfn "%s")

    0 // return an integer exit code

Run the program again

dotnet run -- 123
# error FS0039: The value, namespace, type or module 'Utils' is not defined.
# The build failed. Fix the build errors and run again.

It seems that our build system is unable to resolve the newly created file which in turn led to Utils module not being recognized. Before we fix this, let's take a quick look at hello-world.fsproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net5.0</TargetFramework>
    <RootNamespace>hello_world</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Program.fs" />
  </ItemGroup>

</Project>

If you look carefully, you might notice that ItemGroup tag references Program.fs. F# build system uses this list to resolve files it needs to compile.

Files listed here must be sorted in topological order (no cyclic dependencies are allowed).
Any file listed here can be used without an import statement.
Whenever a file is moved to another directory, fsproj.xml is the only place you will need to update
There are tools to automate the process of populating fsproj.xml.

With that being said, let's update fsproj.xml to reference Utils.fs

  <ItemGroup>
    <Compile Include="Utils.fs" />
    <Compile Include="Program.fs" />
  </ItemGroup>

Running the program again should work without any errors

dotnet run -- 123
# 321
# 231
# 213
# 312
# 132
# 123

Adding tests

We are going to use NUnit for our testing which means we need to install it along with some other packages

dotnet add package NUnit
dotnet add package NUnit3TestAdapter
dotnet add package Microsoft.NET.Test.Sdk

Check if your fsproj.xml references the new packages that were installed

  <ItemGroup>
    <Compile Include="Utils.fs" />
    <Compile Include="Program.fs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
    <PackageReference Include="NUnit" Version="3.12.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
  </ItemGroup>

And now it's time to write some unit tests. In F#, tests are normal functions annotated with the special Test attribute. This means were are free to write our unit-tests anywhere as long it is annotated properly. In this case, I chose to mimic Rust which stores its unit-tests in a nested module inside the same file that is being tested while storing integration-tests inside a tests folder.

// Utils.fs

module Utils

let permute list =
    // code omitted


module Tests =
    open NUnit.Framework

    [<Test>]
    let ``When an empty list is permuted expect to get empty lists`` () =
        let permutationCount = [] |> permute |> List.length
        Assert.AreEqual(0, permutationCount)

    [<Test>]
    let ``When [1;2;3] is permuted expect to get 6 lists`` () =
        let permutationCount = [1;2;3] |> permute |> List.length
        Assert.AreEqual(6, permutationCount)

We can use the following command to run our tests

dotnet test
# Starting test execution, please wait...
#
# A total of 1 test files matched the specified pattern.
#
# Test Run Successful.
# Total tests: 2
#      Passed: 2
# Total time: 3.3699 Seconds

Building a shareable executable

We can use dotnet publish to build an executable that can be shared with the world. We are using self-contained flag to bundle .NET runtime with our executable. This will let us run our program in any environment regardless of the presence of .NET runtime or not. Note that this comes at expense of file size.

# Remember to customize -r flag according to your platform https://docs.microsoft.com/en-us/dotnet/core/rid-catalog
dotnet publish -c Release -r win10-x64 --self-contained

You can now publish the folder that is created at hello-world\bin\Release\<dotnet version>\<rid>\

References

Computing permutations of a list in F#

Mohamed Dahir — Fri, 05 Jun 2020 20:52:56 +0000

TL;DR, here is the final code.

let permute list =
  let rec inserts e = function
    | [] -> [[e]]
    | x::xs as list -> (e::list)::(inserts e xs |> List.map (fun xs' -> x::xs'))

  List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

The algorithm

To get all permutations of a list, we can use the insert algorithm.

First, we have inserts function which gives us all the possible ways we can insert an element in a list. For example, if you had a list of [1;2], inserting 3 will give you [3;1;2], [1;3;2] and [1;2;3].

Next, we build our permutation list by inserting each element from the original list to each item in our permutation list using inserts function.

Here how we can compute permutations of [1;2;3]

                     insert 1 []
                        |
                     insert 2 [1]
                        |
      +-----------------+----------------+
    insert 3 [1;2]              insert 3 [2;1]
           |                         |
 +---------+--------+      +---------+---------+        
 |         |        |      |         |         | 
[3;1;2] [1;3;2] [1;2;3]   [3;2;1] [2;3;1] [2;1;3]

Therefore permuting [1;2;3] gives us [3;1;2], [1;3;2], [1;2;3], [3;2;1], [2;3;1] and [2;1;3].

Implementation in F#

The main thing to implement is the inserts function.

To operate on a list, we normally use recursion and pattern matching.

First we pattern match on the passed list and deconstruct it to a head and tail. Next we operate on the head. After that, we pass the tail recursively to the same function.

let rec inserts e list =
  match list with
  // if list is empty then return empty
  | [] -> []
  // else deconstruct the list into a head and a tail and
  // prepend head to the result of working on the tail
  | head::tail -> head::(inserts e tail)

inserts 9 [1;2;3] // [1;2;3]

Let us change the function to prepend e to every head

let rec inserts e list =
  match list with
  | [] -> [e]
  | head::tail -> e::head::(inserts e tail)

inserts 9 [1;2;3] // [9;1;9;2;9;3;9]

Next, we change the function to prepend e to the slice of list we currently have.

let rec inserts e list =
  match list with
  | [] -> [[e]]
  | head::tail -> (e::list)::(inserts e tail)

inserts 9 [1;2;3] // [[9;1;2;3];[9;2;3];[9;3];[9]]

Notice how the slices keep losing their heads? We need to give it back so they can be whole again.

let rec inserts e list =
  match list with
  | [] -> [[e]]
  | head::tail -> (e::list)::(inserts e tail |> List.map (fun tail' -> head::tail'))

inserts 9 [1;2;3] // [[9;1;2;3];[1;9;2;3];[1;2;9;3];[1;2;3;9]]

Now that we have the inserts function, we use it to compute permutations by starting with an empty list and inserting each element in our original list to each element in our permutations list.

In imperative form, our code would be something like this.

let permutations = [[]]
for (let i = 0; i < arr.length; i++) {
  let temp = []
  for (let j = 0; j < permutations.length; j++) {
    temp.push(inserts(arr[i], permutations[j]))
  }
  permutations = [...temp]
}

But we want to do this in functional style so we will use List.fold to achieve the same thing.

let rec inserts e list =
  match list with
  | [] -> [[e]]
  | head::tail -> (e::list)::(inserts e tail |> List.map (fun tail' -> head::tail'))

let permute list =
  // List.collect is equivalent to flatMap in javascript
  List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

Because inserts function is only used inside permute, we will move it inside permute

let permute list =
  let rec inserts e list =
    match list with
    | [] -> [[e]]
    |  head::tail -> (e::list)::(inserts e tail |> List.map (fun tail' -> head::tail'))

  List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

Finally, we make our code more concise by renaming head and tail to x and xs respectively and by using the function keyword for pattern matching.

let permute list =
  let rec inserts e = function
    | [] -> [[e]]
    | x::xs as list -> (e::list)::(inserts e xs |> List.map (fun xs' -> x::xs'))

  List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

Bonus: We can get to even more concise syntax by replacing List.map with list comprehension syntax.

let permute list =
  let rec inserts e = function
    | [] -> [[e]]
    | x::xs as list -> (e::list)::[for xs' in inserts e xs -> x::xs']

  List.fold (fun accum x -> List.collect (inserts x) accum) [[]] list

References

Getting Started with F# the Easy Way

Mohamed Dahir — Wed, 25 Dec 2019 21:53:55 +0000

If you want to try F# but without the project setup it requires, then you might try one these which are easier:

Online dotnet compiler

Try F# using the online dotnet compiler. Don't forget to choose F# from the language dropdown on the left-hand side.

To follow the rest of this guide, you will need to install dotnet cli.

F# repl

You can write F# code interactively by using repl. The repl can be started by running dotnet fsi in the command-line. Each statement you write should be terminated with double semicolons. To exit the repl, type Ctrl+D.

Use `.fsx` extension

Typing directly into the repl can be hard, that is why F# lets you edit your code in a .fsx file with your favorite editor and load it in the repl afterwards.
To do this, run dotnet fsi --use:<filename> (Don't include < >).

Vscode with Ionide

Install Vscode and its Ionide extension. With this setup, you can highlight any code you want to test then hit alt-enter to send it to the repl.

You could also use the arrow button in the top right-hand corner to send the whole file to the repl.

If you get fsi not found error, you can fix it by enabling Fsharp: Use Sdk Scripts in your Vscode settings.

Extra: Using multiple `.fsx` files

To import some .fsx file into your other .fsxfile, you can use #load directive. For example, if you want to load B.fsx in A.fsx

// B.fsx

let rec calculateFuel mass =
    let fuel = (mass / 3) - 2
    if fuel > 0 then fuel + calculateFuel fuel
    else 0

// A.fsx

#load "B.fsx" // this loads B.fsx file

// Now you can either
B.calculateFuel 100

// or
open B
calculateFuel 100

Extra: Unit Testing `.fsx` files

Simple testing can be done manually via the repl. In the event you need to do several tests after each change, you might write your tests in another .fsx file. For Example, this is how I tested my code for day1 puzzle of advent of Code 2019

// Day01.fsx

let calculateFuel1 mass = (mass / 3) - 2

let rec calculateFuel2 mass =
    let fuel = (mass / 3) - 2
    if fuel > 0 then fuel + calculateFuel2 fuel
    else 0

// Day01Test.fsx

#load "../Day01.fsx"
open Day01

let ``calculateFuel1: mass of 12`` = (calculateFuel1 12) = 2
let ``calculateFuel1: mass of 14`` = (calculateFuel1 14) = 2
let ``calculateFuel1: mass of 1969`` = (calculateFuel1 1969) = 654
let ``calculateFuel1: mass of 100756`` = (calculateFuel1 100756) = 33583

let ``calculateFuel2: mass of 14`` = (calculateFuel2 14) = 2
let ``calculateFuel2: mass of 1969`` = (calculateFuel2 1969) = 966
let ``calculateFuel2: mass of 100756`` = (calculateFuel2 100756) = 50346

Next, we load our test file in the repl. Our tests pass when all bindings in our test file evaluate to true. Notice how F# let us write descriptive names using double backticks.

Extra: Some Useful F# resources

F# for fun and profit is a comprehensive site for everything F# related. It also hosts many F# talks. Two videos which I recommend are Functional programming design patterns and Domain Modeling Made Functional.
F# collections docs I use this whenever I need to find a function such as map, scan, fold, pairwise, etc for operating on collections (List, Map, Seq, Set, etc).
Coursera's Programming Languages, Part A. This course teaches functional programming using standard ML, a language that shares many similarities with F#.

Does your favorite language X

Mohamed Dahir — Wed, 11 Dec 2019 09:29:33 +0000

has support for a repl?
can represent two types in one without too much hassle i.e sum type, union type?
has no null pointer exception?
can statically infer types?
has operator overloading?
can do recursion without blowing the stack?

If you nodded yes to all those questions then congratulations, you should keep using it.

If not, maybe you should take a look at reasonml which is an ocaml alternative syntax that mimics javascript language. You could also try its closer cousin F# which fixes some of the warts which you may encounter in ocaml/reasonml (using ./ for float division, tooling, etc).

The best way to learn a new language IMHO is to use it for solving a problem. Advent of code 2019 is publishing a new puzzle every day in December which you can solve in any language. I am currently using this opportunity to learn F# and so can you 😀.

How to version control docker-compose file

Mohamed Dahir — Sat, 29 Jun 2019 18:10:00 +0000

At some point docker-compose file gets complicated and we need to version control it. the typical directory structure looks like this:

todo
├── .env
├── docker-compose.yml
├── todo-api/
├── todo-worker/
└── todo-database/

and our docker-compose.yml file is like this:

# todo/docker-compose
version: '3.1'

services:
  todo-database:
    image: postgres:11.3
    volumes:
      - ./todo-database:/docker-entrypoint-initdb.d/
    environment:
      POSTGRES_PASSWORD: $POSTGRES_PASSWORD

  todo-api:
    build: ./todo-api
    environment:
      APP_KEY: $APP_KEY
      DATABASE_URL: postgres://postgres:${POSTGRES_PASSWORD}@todo-database:5432/postgres

  todo-worker:
    build: ./todo-worker
    environment:
      DATABASE_URL: postgres://postgres:${POSTGRES_PASSWORD}@todo-database:5432/postgres

and here is our .env file

# todo/.env
POSTGRES_PASSWORD=secret-1
APP_KEY=secret-2

So how we can version control it?

One way to do it is by creating todo-compose/ folder and moving .env and docker-compose.yml files to todo-compose/ so we can initialize a git repo in it

$ mkdir todo-compose
$ mv docker-compose.yml .env todo-compose/

then we rename .env to .env.example and remove all passwords in it so we can use it as a reference. now todo-compose/ should be like this:

todo-compose
├── .env.example
└── docker-compose.yml

because we moved docker-compose.yml file to its own folder, we will have to modify each service build and volume keys to move up one directory like this:

# todo/todo-compose/docker-compose.yml
version: '3.1'
  # ...
  todo-database:
    volumes:
      - ../todo-database:/docker-entrypoint-initdb.d/
  # ...
  todo-api:
    build: ../todo-api
  # ...
  todo-worker:
    build: ../todo-worker
  # ...

but can we do better? it turns out that we can use symbolic links to make docker think that docker-compose.yml exists in todo/ while in reality it is inside todo/todo-compose/

$ ln -s todo-compose/docker-compose.yml ./docker-compose.yml

now we copy our .env.example reference file to todo/

$ cp todo-compose/.env.example ./.env

next we modify our newly created .env to contain project passwords. now our directory structure should be like this:

todo
├── .env
├── docker-compose.yml -> todo-compose/docker-compose.yml
├── todo-compose/
│   ├── .env.example
│   └── docker-compose.yml
├── todo-api/
├── todo-worker/
└── todo-database/

One benefit that this method has is if you have multiple docker files like this:

todo-compose
├── .env.example
├── docker-compose.yml/
├── docker-compose.prod.yml/
└── docker-compose.dev.yml/

and you were issueing docker-compose -f docker-compose.yml -f docker-compose.dev.yml up in development and docker-compose -f docker-compose.yml -f docker-compose.prod.yml up in production. now you just have to do

# in development
$ ln -s todo-compose/docker-compose.yml ./docker-compose.yml
$ ln -s todo-compose/docker-compose.dev.yml ./docker-compose.override.yml

# in production
$ ln -s todo-compose/docker-compose.yml ./docker-compose.yml
$ ln -s todo-compose/docker-compose.prod.yml ./docker-compose.override.yml

then you can use the same command docker-compose up for development and production

this post first appeared at https://ducaale.github.io

Some helpful docker links

Mohamed Dahir — Sat, 29 Jun 2019 17:33:02 +0000

It's been 1 year plus 2 month since i wrote my first docker-compose.yml file.
Every once in a while i stumble upon a docker feature that i didn't know existed.
here are some links that were helpful:

Learn docker youtube series:

General docker tips:

https://blog.cloud66.com/10-tips-for-docker-compose-hosting-in-production/

Caching dependencies or how can you speed up docker builds:

Using dev and prod docker-compose files:

https://stackoverflow.com/a/53522670/5915221

Using .env for storing secrets:

https://stackoverflow.com/a/50201232/5915221

A fully automated HTTPS server:

https://github.com/SteveLTN/https-portal

CI/CD with docker and jenkins:

https://hackernoon.com/deploying-frontend-applications-the-fun-way-bc3f69e15331

DEV Community: Mohamed Dahir

My adventures in ML Land

Discovering and Learning F#

Things I didn't like about F#

Moving to OCaml

Haskell

Everything as an expression

Binding and continuations in ML

Enter OCaml

Killing all birds with one stone

CLI tools I use

1. Neovim

2. fzf

3. ngrok

4. qrcp

5. zsh + oh-my-zsh

6. HTTPie

7. fx

8. Z

9. Others that I don't use so often

How to Setup a minimal F# Project

Importing files

Adding tests

Building a shareable executable

References

Computing permutations of a list in F#

The algorithm

Implementation in F#

References

Getting Started with F# the Easy Way

Online dotnet compiler

F# repl

Use .fsx extension

Vscode with Ionide

Extra: Using multiple .fsx files

Extra: Unit Testing .fsx files

Extra: Some Useful F# resources

Does your favorite language X

How to version control docker-compose file

So how we can version control it?

Some helpful docker links

Use `.fsx` extension

Extra: Using multiple `.fsx` files

Extra: Unit Testing `.fsx` files