RΞCURSION

A Year Is Enough to Know What You Don't Know

Tue, 14 Jul 2026 09:00:00 +0300

This post reflects on one year in leadership, tracing lessons about uncertainty, difficult conversations, team silence, mentorship, decision-making, and the cost of trying to lead on empty.

The Mathematics of Allocating Risk Instead of Capital

Tue, 16 Jun 2026 09:00:00 +0300

This post explains risk parity through equal risk contribution, showing why capital weights can hide concentrated portfolio risk. We derive the core variance and risk contribution formulas, compare ERC with inverse-volatility weighting, and discuss covariance estimation, leverage, and regime risk.

Two Wheels and a Heartbeat

Tue, 16 Jun 2026 09:00:00 +0300

This essay makes the case for motorcycles as the best vehicle ever made, blending road culture, Nairobi traffic realities, rider discipline, and the emotional pull of two wheels.

Introduction to Stochastic Differential Equations

Sat, 09 Aug 2025 00:00:00 +0000

This post introduces SDEs and the Euler-Maruyama method, demonstrating their application in finance and ESG modeling. Through F# simulations of stock prices and renewable energy adoption, we show how to implement and visualize SDE solutions, highlighting their importance for handling uncertainty.

Seamless R Integration in .NET with R.NET: A Step-by-Step Guide

Mon, 04 Aug 2025 16:54:25 +0600

This post explores how R.NET enables seamless in-process R integration in .NET, focusing on statistical computations. Through a simple F# example calculating mean and standard deviation, we demonstrate how to set up R.NET, call R functions, and handle common pitfalls, empowering .NET developers to leverage R’s power.

Modelling Relationships in F# for Domain-Driven Design

Mon, 21 Jul 2025 08:06:25 +0600

This post explores F#’s discriminated unions for domain-driven design, focusing on financial systems. Through examples like modeling financial instruments, transactions, and account types, we demonstrate how to encode business rules, ensure type safety, and simplify complex domains using F#.

Understanding Functors and Monads in F# with Statistical and Financial Models

Mon, 28 Apr 2025 08:06:25 +0600

This blog post demystifies functors and monads in F# through real-world statistical and financial modeling examples. Learn how Option, Result, and Async types simplify handling missing data, errors, and asynchronous computations, enabling robust and composable code for data processing, risk modeling, and Monte Carlo simulations.

What’s New in F# 9 for Quant Developers

Wed, 23 Apr 2025 19:51:10 +0300

This post reviews F# 9 features through a quant-developer lens, covering language improvements that make financial modeling, data workflows, and high-integrity code easier to express.

Simple Moving Average Crossover Strategy in F#

Wed, 02 Apr 2025 21:37:25 +0600

This post builds a simple moving average crossover strategy in F#, explaining short and long windows, crossover signals, thresholds, and the structure of a testable trading pipeline.

Optimizing Pattern Matching in F# for Better Performance

Mon, 03 Mar 2025 21:37:25 +0600

This post explores pattern matching in F# and shows how to structure match expressions for clearer, more efficient functional code when working with larger data shapes.

Attributing for Risk in Portfolio Management

Mon, 02 Dec 2024 21:37:25 +0600

This post explains portfolio risk attribution, showing how volatility and risk contribution formulas help identify which assets drive overall portfolio risk.

Memoization with Fibonacci

Mon, 04 Nov 2024 21:37:25 +0600

This post explains memoization as a functional performance optimization technique, using repeated computations to show how caching improves F# code efficiency.

A Better Way to Manage Dependencies in F#

Tue, 22 Oct 2024 21:37:25 +0600

This post introduces Paket as an alternative dependency manager for F# and .NET projects, focusing on clearer dependency resolution and maintainable project setup.

Currying and Partial Application in F#

Mon, 07 Oct 2024 08:06:25 +0600

This post breaks down currying and partial application in F#, explaining how multi-argument functions can be composed, reused, and specialized for cleaner functional programming workflows.

Enhancing Code Maintainability with the F# 'Option' Type

Tue, 17 Sep 2024 08:06:25 +0600

This post introduces the F# Option type as a safer alternative to nulls, using pattern matching and higher-order helpers to make missing values explicit and maintainable.

Mastering Python's Exceptional Complexity

Thu, 14 Sep 2023 06:00:20 +0600

This post explains Python exception handling from syntax errors through try, except, else, and finally blocks, showing how structured error handling improves resilience, cleanup, and code clarity.

Functional Programming

Thu, 20 Apr 2023 19:17:21 +0300

This post introduces functional programming principles such as pure functions, immutability, first-class functions, and higher-order composition, with practical F# examples.

Introduction

Mon, 08 Jun 2020 08:06:25 +0600

A short starter post that validates the site’s post layout, sidebar placement, author metadata, multilingual setup, and local hero image behavior.

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

A sample go program is show here.

package main

import "fmt"

func main() {
 message := greetMe("world")
 fmt.Println(message)
}

func greetMe(name string) string {
 return "Hello, " + name + "!"
}

Run the program as below:

$ go run hello.go

Variables

Normal Declaration:

var msg string
msg = "Hello"

Shortcut:

msg := "Hello"

Constants

const Phi = 1.618

Basic Types

Mon, 01 Jan 0001 00:00:00 +0000

Strings

str := "Hello"

Multiline string

str := `Multiline
string`

Numbers

Typical types

num := 3 // int
num := 3. // float64
num := 3 + 4i // complex128
num := byte('a') // byte (alias for uint8)

Other Types

var u uint = 7 // uint (unsigned)
var p float32 = 22.7 // 32-bit float

Arrays

// var numbers [5]int
numbers := [...]int{0, 0, 0, 0, 0}

Pointers

func main () {
 b := *getPointer()
 fmt.Println("Value is", b)

func getPointer () (myPointer *int) {
 a := 234
 return &a

a := new(int)
*a = 234

Pointers point to a memory location of a variable. Go is fully garbage-collected.

Flow Control

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
 rest()
} else if day == "monday" && isTired() {
 groan()
} else {
 work()
}

if _, err := doThing(); err != nil {
 fmt.Println("Uh oh")

Switch

switch day {
 case "sunday":
 // cases don't "fall through" by default!
 fallthrough

 case "saturday":
 rest()

 default:
 work()
}

Loop

for count := 0; count <= 10; count++ {
 fmt.Println("My counter is at", count)
}

entry := []string{"Jack","John","Jones"}
for i, val := range entry {
 fmt.Printf("At position %d, the character %s is present\n", i, val)

n := 0
x := 42
for n != x {
 n := guess()
}

File Manipulation

Mon, 01 Jan 0001 00:00:00 +0000

Condition

if day == "sunday" || day == "saturday" {
 rest()
} else if day == "monday" && isTired() {
 groan()
} else {
 work()
}

if _, err := doThing(); err != nil {
 fmt.Println("Uh oh")

Bash Variables

Mon, 01 Jan 0001 00:00:00 +0000

Variable

NAME="John"
echo $NAME
echo "$NAME"
echo "${NAME}

Condition

if [[ -z "$string" ]]; then
 echo "String is empty"
elif [[ -n "$string" ]]; then
 echo "String is not empty"
fi