Lander's blog

Resource acquisition is initialization (RAII)

Thu, 19 Mar 2026 00:00:00 -0500

Resource acquisition is initialization (RAII) is a programming idiom, or design pattern, used for managing resources such as memory, file handles, mutexes, and more. The key idea is that resources are tied to the lifetime of objects. When an object goes out of scope, its destructor is automatically called to release any associated resources.

Why RAII Matters

Manually managing memory (e.g., calling `delete` or `free` after every heap allocation) is error-prone and can lead to memory leaks, double frees, or resource exhaustion. The same principle applies to other resources like locks; forgetting to release a mutex can cause deadlocks.

Smart pointers in C++

Thu, 19 Mar 2026 00:00:00 -0500

Previous: Resource acquisition is initialization (RAII)

In C++, smart pointers are RAII wrappers for raw pointers. They eliminate the need to use raw pointers and manually call new / delete in order to get them. The three variations are std::unique_ptr, std::shared_ptr, and std::weak_ptr.

`std::unique_ptr`

Likely the most common of the three, std::unique_ptr will fit in most occasions where a raw pointer was desired. It is meant to be used when there is unique ownership of a resource. For example, if a class is meant to manage a pointer to another class, instead of manually calling new in the constructor, and delete in the desturctor, using a unique pointer will automatically deallocate the owned resource when the primary class is destructed.

Asynchronous programming

Wed, 18 Mar 2026 00:00:00 -0500

Previous: Concurrency

Asynchronous programming is a form of programming where the programs execution is non-linear.

This is achieved by implementing “futures” or “promises”, which will return a value at some point, but not immediately. It breaks the flow of execution that is typically expected from reading source code.

In Rust, this is achieved by the async and await keywords.

Async is typically a better option if the program is I/O bound instead of CPU bound.

Concurrency is not parallelism

Wed, 18 Mar 2026 00:00:00 -0500

Previous: Concurrency, Parallelism

In computer science, the concepts of concurrency and parallelism are related, but distinct ideas. There is a talk by Rob Pike, the co-author of Golang, of the same name as this note where he outlines the difference between the two.

I’ll start with an analogy used in “The Rust Programming Language” book in the section for asynchronous programming. Concurrency is when a single person is assigned multiple tasks. They can switch between these tasks until each one is complete, but cannot work on more than one at a time. Concurrency is possible on a single core CPU while parallelism means that things are getting done at the exact same time.

Interviewing

Wed, 18 Mar 2026 00:00:00 -0500

Multithreading

Wed, 18 Mar 2026 00:00:00 -0500

Previous: Concurrency

Multithreading is a form of concurrency where a program can be executing on multiple threads. There is a difference between operating system threads and language threads, but that is not as apparent in languages like C++ and Rust where there is a 1:1 relationship between the two.

Parallelism

Wed, 18 Mar 2026 00:00:00 -0500

Concurrency

Sun, 08 Mar 2026 00:00:00 -0600

Previous: Operating system

Synchronization primitives:

Condition variable

Sun, 08 Mar 2026 00:00:00 -0600

Previous: Concurrency

A condition variable is a synchronization primitive that allows threads to wait efficiently until a specific condition becomes true. They are usually used in conjunction with a lock.

Lock (Mutex)

Sun, 08 Mar 2026 00:00:00 -0600

Previous: Concurrency

A lock or mutex (short for mutual exclusion) is a synchronization primitive that prevents data races by only allowing a single thread inside a critical section at a time.

Semaphore

Sun, 08 Mar 2026 00:00:00 -0600

Previous: Concurrency

A semaphore is a synchronization primitive similar to locks and condition variables. It provides two operations, signal() and wait(), and keeps track of a count (an integer).

wait: Decrements the semaphore’s count. If the new value is less than zero, it blocks the calling thread.
signal: Increments the semaphore’s count. If the count was negative before the increment, it wakes one waiting thread and moves it to the ready queue.

System design interview template

Sun, 08 Mar 2026 00:00:00 -0600

The system design interview template is from “System Design Interview” by Alex Xu, and consists of four steps to guide interviewees through designing a system.

The fours steps are:

Step 1 - Understand the problem and establish design scope

Ask clarifying questions, get all of the requisite informatioe.

Step 2 - Propose high-level design and get buy-in

Create initial blueprint and get help from the interviewer. Draw diagrams, and do necessary calculations.

Backtracking

Sun, 22 Feb 2026 00:00:00 -0600

Previous: Algorithm, Depth-first search

Backtracking is an algorithmic paradigm that incrementally builds solutions while discarding invalid states.

Base case
Choices
Constraints
Backtrack

def backtrack(params):
 if base_case_condition:
 save_result
 return

 for choice in choices:
 if violates_constraints:
 continue

 make_choice
 backtrack(updated_params)
 undo_choice # Backtracking Step

Depth-first search

Sun, 22 Feb 2026 00:00:00 -0600

Previous: Algorithm

Depth-first search (DFS) is a graph traversal algorithm that fully explores one path before going back to explore others. This is in contrast to breadth-first search which explores all nodes on a layer or level before moving on to another. At its core, DFS uses a stack data structure to implement this behavior. Since a stack can be replicated via recursion, it is often easier to implement DFS recursively instead of iteratively.

Functors in C++

Sun, 22 Feb 2026 00:00:00 -0600

Previous: C++, Lambda expressions in C++

Functors in C++ are classes or structs that overload operator(), allowing instances to be called like regular functions. Because they are objects, they can carry state between calls, which is something a plain function cannot do. Under the hood, lambda expressions are simply compiler-generated functors.

Inheritance in C++

Sun, 22 Feb 2026 00:00:00 -0600

Previous: Object-oriented programming, C++

Inheritance allows a derived class to acquire the properties and behaviors of a base class. It is a core concept of object-oriented programming and a prime example of subtype polymorphism. The following are not inherited from the base class: constructors, destructors, overloaded operators, and friend functions.

class Animal {
public:
 string name;
 virtual void speak() { cout << "..."; }
};

class Dog : public Animal {
public:
 void speak() override { cout << "Woof!"; }
};

Virtual Inheritance

When a member function is marked virtual, the compiler generates a vtable (virtual table) for the class and attaches a vpointer to each instance. At runtime, function calls are dispatched through the vtable, allowing the correct overridden method to be called regardless of the pointer type. This is known as dynamic dispatch.

Three different types of index notes

Sun, 22 Feb 2026 00:00:00 -0600

Previous: Zettelkasten

In A System for Writing by Bob Doto, he suggests three types of indexes that will help you navigate your zettelkasten as it grows larger.

Hub Notes These notes are more just launch off point into your zettelkasten. The take a few of the notes that you have in a subject as a starting point and link them here. It will serve as a jumping board into your notes in order to find more information on the subject you desire.
Structure Notes These are meant to expand upon a topic, becoming a central location for your thoughts and connections. Explain all connections.
Keyword Index: This is allegedly what Niklas Luhmann used the most in his personal zettelkasten. This is most akin to an index at the back of a book, where keywords list their locations in order for the reader to find them. You could have multiple of these kinds of note, each with a different criteria, but generally I think one would be more than sufficient. Most people would opt to imitate what is found in books, while others can index by things like how the notes make them feel or where the notes were taken.

Abstraction

Wed, 18 Feb 2026 00:00:00 -0600

Access specifiers in C++

Wed, 18 Feb 2026 00:00:00 -0600

Previous: C++

In C++, access specifiers control how class, struct, or union members can be accessed from outside the class or by derived types. The three available specifiers are public, protected, and private.

Public and private are the most commonly used, while protected is mainly relevant in inheritance hierarchies. It allows derived classes to access certain members while still hiding them from outside code.

The following table summarizes the accessibility rules:

Auto keyword in C++

Wed, 18 Feb 2026 00:00:00 -0600

The auto keyword has existed since the earliest versions of C++, but its modern meaning was introduced in C++11. Originally, auto specified automatic storage duration, which was the default for local variables and rarely used. In C++11 and later, auto allows the compiler to deduce the type of a variable from its initializer.

The use of auto defers type deduction to the compiler, allowing you to avoid explicitly writing out the type of the data being assigned. This is useful for simplifying code, especially when dealing with complex types such as iterators or lambda expressions.

Recursive lambda expressions in C++

Wed, 18 Feb 2026 00:00:00 -0600

Previous: Lambda expressions in C++

Unlike Python, C++ lambdas don’t support generic recursion. There are workarounds, but they all come with meaningful drawbacks. Additionally, I believe recursion has little place in production code, recursive lambdas even less so. The options below are fun to know, but should be considered trivia at best.

`std::function`

#include <functional>
std::function<int(int)> factorial = [&](int n) -> int {
 return n <= 1 ? 1 : n * factorial(n - 1);
};

Works from C++11 onward. The main drawback is that you must spell out all parameter types inside the std::function template, which largely defeats the brevity that made you want a lambda in the first place. There’s also a runtime overhead cost from type erasure.

Declaration, initialization, instantiation

Mon, 16 Feb 2026 00:00:00 -0600

Previous: Variable assignment and initialization in C++

Declaration: Telling the compiler that a variable or object exists, specifying its type. No memory for the actual value is necessarily allocated (depends on context). Example:

int x;
Foo* p;

Initialization: Assigning an initial value to a variable or object. Happens after declaration or at the same time. Example:

int x = 5;
Foo obj(10);

Instantiation: Creating an instance of a class (an actual object). Involves memory allocation for the object. Example:

Decltype keyword in C++

Mon, 16 Feb 2026 00:00:00 -0600

Previous: Auto keyword in C++

The decltype keyword and operator in C++ is used to query the type of a variable or an expression. It is related to auto in that it is a form of type deduction, but it does not follow the same rules. decltype almost always yields the type of a variable or expression without any modifications.

Euclidean algorithm

Mon, 16 Feb 2026 00:00:00 -0600

Previous: Algorithm

The Euclidean algorithm or Euclid’s algorithm is for efficiently finding the greatest common divisor of two numbers. The idea of the algorithm is based on the observation that, if r is the remainder when a is divided by b, then the common divisors of a and b are precisely the same as the common divisors of b and r. This we can use the equation: GCD(a,b) == GCD(b,r).

Linked List

Mon, 16 Feb 2026 00:00:00 -0600

Previous: Data structure

One of the big benefits of a linked list over a Dynamic Array is that modifying a known element is an O(1) operation. Meaning that modifying the beginning of a list isn’t O(n).

A downside of using them is that you loose O(1) random access. Because arrays store an address that points to a contiguous block of memory, a little arithmetic will allow you to directly get to the elemetn at i, but linked lists are stored on the heap and are not contigious

Recursively Enumerable

Mon, 16 Feb 2026 00:00:00 -0600

Previous: Mathematics

A set S of natural numbers is recursively enumerable if there exists an algorithm that enumerates its elements: s₁, s₂, s₃, … (the algorithm may run forever for infinite sets).

Examples: x² generates {0, 1, 4, 9, 16, …}, the primes {2, 3, 5, 7, 11, …}

Every computable set is recursively enumerable, but not every recursively enumerable set is computable.

Recursive enumeration is the process of generating new elements from old ones by fixed rules.

References in C++

Mon, 16 Feb 2026 00:00:00 -0600

Previous: C++

Added in C++11 was the distinction between lvalue and rvalue references, which enabled the possibility of many new features mainly move semantics. References are not objects, they are typically implemented as pointers underneath, and their primary purpose is to serve as an alias for another value. They are supplied with more safety constraints and better syntax than raw pointers. That said, they do also suffer from issues like dangling that pointers do.

Variable assignment and initialization in C++

Mon, 16 Feb 2026 00:00:00 -0600

Previous: C++

int a; // default-initialization (no initializer)

// Traditional initialization forms:
int b = 5; // copy-initialization (initial value after equals sign)
int c ( 6 ); // direct-initialization (initial value in parenthesis)

// Modern initialization forms (preferred):
int d { 7 }; // direct-list-initialization (initial value in braces)
int e {}; // value-initialization (empty braces)

By default assignment copies values. Copy initialization is used whenever values are implicitly copied: passing arguments, by value, returning by value.

List initialization is probably the best and easiest to recommend for modern C++ programming.

Computer science

Sun, 15 Feb 2026 00:00:00 -0600

Lambda calculus

Sun, 15 Feb 2026 00:00:00 -0600

Previous: Computer science

Lambda calculus is a Formal System in mathematics for expressing computation based on function abstraction using variable binding and substitution. Functional programming derives its core concepts from lambda calculus. The LISP family of languages is directly based on it. In 1937, Alan Turing proved that lambda calculus and Turing machine are equivalent models of computation.

Features of the language:

Single-letter variable names (a-z)
Application: ab means call function a with parameter b (left associative, so abc = (ab)c)
Abstraction: define anonymous functions using λ
Parentheses for grouping expressions

Grammar:

Models of Computation

Sun, 15 Feb 2026 00:00:00 -0600

Previous: Computer science

In computer science, a model of computation is a formal framework that describes how computations are performed. Lambda calculus and general recursive functions are functional models, while Turing machines are sequential models. Not all models of computation have equal computational power, but the ones listed below are all Turing-complete and thus equivalent in what they can compute:

Org-mode syntax export test

Sun, 15 Feb 2026 00:00:00 -0600

Table of Contents

Headings
First Level Heading
- Second Level Heading
Text Formatting
Lists
Tables
Source Code Blocks
Quotes and Verses
- Block Quotes
- Verse Blocks
Horizontal Rules
Tags:tag:
- Heading with Single Tag:work:
- Heading with Multiple Tags:work:important:
- Heading with Inherited Tags:project:development:
Properties and Drawers
- Heading with Properties
- Heading with Logbook
Mathematical Expressions (LaTeX)
- Inline Math
- Display Math
Special Symbols and Entities
Macros
Comments
Special Blocks
- Note Block
- Warning Block
Org Babel Features
Miscellaneous
Conclusion

This document demonstrates the full range of Org mode syntax features.

As-if rule in C++

Sat, 14 Feb 2026 00:00:00 -0600

Previous: Compiler optimizations in C++

The as-if rule says that a compiler is allowed to make modifications to a program in attempt to optimize as long as the effects do not affect the observable behavior.

Binary search

Sat, 14 Feb 2026 00:00:00 -0600

Previous: Algorithm

Binary search is an algorithm that finds an item in a sorted array in O(log(n)) time complexity. Given no other information other than the array is sorted it is the optimal algorithm for finding the index of an element if it exists, or if it should exist.

Compiler optimizations in C++

Sat, 14 Feb 2026 00:00:00 -0600

Previous: C++

Phong lighting

Sat, 14 Feb 2026 00:00:00 -0600

Previous: Graphics programming

The Phong lighting model consists of 3 components: ambient, diffuse, and specular lighting.

Ambient lighting is just the base level of ligthing an object receives, from “all” light sources, even if there aren’t any, an object will still be lit with the ambient light source. Generally this is accomplished by dimming all objects by a set value.

Signed distance function

Sat, 14 Feb 2026 00:00:00 -0600

Previous: Ray marching

A signed distnace function returns the distance to the boundary of an object (shape) from a given point. If the point is inside the object, then this value will be negative.

Disjoint set data structure

Fri, 13 Feb 2026 00:00:00 -0600

Previous: Data structure

The disjoint set data structure, also called a union-find data structure, is used in many graph problems to represent a collection of disjoint sets. It provides two main operations: union for joining sets, and find for determining which set an element belongs to.

Useful to think of electricity as an example. If there are a lot of nodes, connecting them will put them in the same circuit, but if two nodes aren’t connected, then they aren’t in the same circuit.

Memory segmentation

Fri, 13 Feb 2026 00:00:00 -0600

Previous: Virtual memory

Memory segmentation is a form of virtual memory management that preceded Memory paging. It divides memory into variable-sized segments (code, stack, heap, etc.) rather than fixed-size pages. Originally implemented with a base-and-bounds technique where each segment has a base address (starting location in physical memory) and a bounds/limit (size of the segment).

Address translation is simple: take the virtual address (offset within segment), add the base register, check against bounds. Each segment can be placed anywhere in physical memory. The MMU tracks segment growth direction (positive for heap, negative for stack).

Ray marching

Fri, 13 Feb 2026 00:00:00 -0600

Previous: Graphics programming

Ray marching is a technique used in graphics programming to draw shapes using signed distance functions. It involves incrementally stepping along a ray by a safe distance (provided by the SDF).

Special member functions in C++

Tue, 10 Feb 2026 00:00:00 -0600

Previous: C++

In C++, special member functions are the functions that the compiler can automatically generate for a class if you don’t declare them yourself. They are responsible for the core object lifecycle and copying/moving behavior. Here’s the full list:

Constructors in C++ are a special member function that is automatically called after a non-aggregate type is created.

Destructors are meant for when an object is being destroyed There is one special member fucntion that if defined will not prevent the others from being implicitly defined by the compiler That is the constructor, I would like some more information about this? what is happening, does defining a copy constructor prevent there from implicitly defining a move

The rule of three, five, and zero in C++

Tue, 10 Feb 2026 00:00:00 -0600

Previous: Copy semantics in C++, Move semantics in C++

The rule of three, five, and zero in C++ are guidelines that help determine which special member functions a class should implement. The rule of three originally stated that if a class implemented a custom destructor, copy constructor, or copy assignment operator, then it should probably implement the other two.

This was updated to the rule of five in C++11 due to the addition of move semantics, adding the move constructor and the move assignemnt operator to the rule of three.

Kruskal's algorithm

Sun, 08 Feb 2026 00:00:00 -0600

Previous: Algorithms

Kruskal’s algorithm is a method of obtaining a minimum spanning tree of an undirected, edge-weighted graph. It makes use of a disjoint set data structure.

The solution using Kruskal’s algorithm requires both the edges and the number of vertices. If the vertices are not explicitly provided, they can be inferred by examining all unique endpoints in the edge list. Moving on to the actual algorithm, sort the edges by weight in ascending order and then begin adding them to the MST using the disjoint set to detect cycles. An edge is added only if it connects two different components and doesn’t create a cycle. A minimum spanning tree has been produced when the number of edges added is equal to the number of vertices minus one.

Sorting

Sun, 08 Feb 2026 00:00:00 -0600

Previous: Algorithm

Most common types of sorts

Quicksort
Mergesort
Radix sort

Stability

Stable sorting algorithms sort equal elements in the same order that they appear in the input. Relative order of equal value elements will be preserved in a stable sort. Stability is a non-issue on sets where all elements are distinct, or when elements are indistinguishable, like primitive values.

Stability is useful when stacking sorts, like sorting a deck of cards initially by the rank, and then followed by the suit. This will produce ordered sections of suits, whereas an unstable sort would not preserve this order.

Cache affinity

Wed, 04 Feb 2026 00:00:00 -0600

Previous: Operating system

Cache affinity, also called processor affinity or CPU pinning, is the concept that a process when run on a particular CPU, builds up a fair bit of state in the caches (and TLBs) of the CPU. When the process is switched out and back in, it would be adventageous for it to run on the same CPU.

Forwarding references in C++

Tue, 03 Feb 2026 00:00:00 -0600

Previous: References in C++

Forwarding references (also known as “universal references”) can bind to both lvalues and rvalues. The syntax is generally the same as rvalue references T&&, but they arise in two specific contexts: function template parameters, and auto declarations. Both cases have to deal with type deduction. Form must be T&& precisely, and type deduction must occur, otherwise T&& denotes an rvalue reference.

Example:

void f(Widget&& param); // rvalue reference

auto&& var2 = var1; // unversal reference

template<typename T>
void f(T&& param); // universal reference

Perfect forwarding in C++

Tue, 03 Feb 2026 00:00:00 -0600

Previous: Forwarding references in C++

Perfect forwarding is a technique where a forwarding reference is passed to another function using std::forward. This action preserves the value category of the original argument allowing for proper semantics to be invoked and compiler optimization.

Entity component system

Sat, 31 Jan 2026 00:00:00 -0600

Previous: Bevy

Entity component sysetm (ECS) is a design pattern that involves breaking a program up into entities, components, and systems. Entities are unique things which are assigned components, and then processed using systems.

An entity is an ID. A component is a stuct of data. A system is the logic that operates on the components.

Game development

Sat, 31 Jan 2026 00:00:00 -0600

Quaternion

Sat, 31 Jan 2026 00:00:00 -0600

Previous: Transform

A quaternion is a mathematical concept that is incredibly useful in graphics programming and game development. Just as complex numbers form a two-dimensional number system over the reals, quaternions form a four-dimensional number system over the reals.

Multiplication

Comparing quaterions again to complex numbers, multiplication provides a rotation in three-dimensional space. For instance, q * v rotates the vector v by the rotation represented by q.

Transform

Sat, 31 Jan 2026 00:00:00 -0600

Previous: Bevy

A tranform is a primitive component in game programming for representing an object’s position. They are used in most game engines and are a good abstraction for handling the behvavior of an object.

Tranforms generally contain three pieces: position, rotation, and scale. Position and scale are represeted with vectors, and rotation is represented with a quaternion.

class Transform
{
 glm::vec3 position;
 glm::quat rotation;
 glm::vec3 scale;
}

Virtual address space

Sun, 25 Jan 2026 00:00:00 -0600

Previous: Process, Virtual memory

A virtual address space is what is provided by the operating system to each process to provide the illusion of a large, uninterrupted physical address space that the process can use. This virtual space is broken up into multiple different sections which have different rules and uses to a process.

Starting from the very bottom, there will usually be a virtual address of 0, which is used for null pointers. The CPU cannot translate address 0, which results in a page fault being triggered, and the OS terminating the process.

Virtual memory

Sun, 25 Jan 2026 00:00:00 -0600

Previous: Operating system

Virtual memory is an abstraction for processes provided by the operating system. It protects processes from one another, and gives them the illusion of a large, uninteruppted address space.

Hera are some additional notes on the topic:

Algorithm

Sat, 24 Jan 2026 00:00:00 -0600

Algorithm: a finite set of rules that gives a sequence of operations for solving a specific type of problem.

Algorithms have 5 general characteristics:

Algorithms must always terminate after a finite number of steps.
Each step of the algorithm must be precisely defined.
An algorithm has zero or more inputs
An algorithm has one or more outputs.
An algorithm is generally expected to be effective. Could be done using pencil and paper

Bevy

Sat, 24 Jan 2026 00:00:00 -0600

Breadth-first search

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Algorithm

C++

Sat, 24 Jan 2026 00:00:00 -0600

Category theory

Sat, 24 Jan 2026 00:00:00 -0600

Compounding resources

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Habits

Compounding resources are resources which have an exponential growth factor. In the book “Atomic Habits”, James Clear shows that habits are one of these resources, which over time will lead to extraordinary results.

Habits aren’t the only compouding resource though, I can think of multiple other examples: the Zettelkasten, knowledge, and wealth.

The first of these two kind of go hand-in-hand. The Zettelkasten system grows in its ability to produce thoughts the more time, effort, and notes that are put into it. Knowledge is the same way, and the more you possess, the easier it is to acquire more.

Constructors in C++

Sat, 24 Jan 2026 00:00:00 -0600

C++

Constructors are a special member function which are automatically called after a non-aggregate class type object is created. At the point when a constructor is executed, storage for the object has been allocated and the constructor is only performing initialization.

Memory is allocated and then the constructor is called which initializes the object.

Constructors have special syntax, they have no return type (not even void) and their names must match the name of the class they are in. A default constructor is a constructor with no arguments

Copy semantics in C++

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Special member functions in C++

Copy semantics are invoked when an object is needed to be copied. They define specifically “how” the object is going to be copied into the new independent object. The way C++ achieves is with two special member functions: the copy constructor, and copy assignment operator.

The copy constructor

The copy constructor is a special member function that initializes a new object from an existing object of the same type. If you do not declare one, the compiler automatically generates a default version that performs a member-wise copy. This implicit copy constructor is usually adequate, especially for classes that only contain value-type members and do not manage external resources.

Data structure

Sat, 24 Jan 2026 00:00:00 -0600

Destructors in C++

Sat, 24 Jan 2026 00:00:00 -0600

C++

Destructors in C++ are special member functions that handle cleanup when an object goes out of scope or is explicitly deleted. They release resources such as memory, file handles, or network connections and perform necessary teardown tasks.

If a destructor is not declared, the compiler provides a default one. For simple classes without resource management, the default is usually sufficient.

A destructor should generally be public and virtual, or protected and non-virtual. Classes that manage resources often need explicit cleanup before destruction.

Dijkstra's algorithm

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Algorithm

Dijkstra’s algorithm can be seen as a variation of Breadth-first search made to work on graphs with weighted edges. The only real modification to the algorithm is to set up a priority queue instead of a regular queue so at each node, it will look for the next shortest path.

Doom Emacs cheatsheet

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Emacs

Doom Emacs is a mneumonic editor based off Emacs with Vi bindings.

Here are some of the commands that I find myself using most in Doom Emacs.

Keybinds

Follow org link

C-c C-o

Reload Config

space h r r

Find notes

space n r f

Open backlinks

space n r r

Insert structure template

C-c C-,

Org Agenda (open next 10 day view)

space o A a (n)

I actually like the n better since it gives the agenda and non-scheduled TODOs

Dynamic programming

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Algorithm

Dynamic programming is an mathematical optimization technique that solves complex problems by solving smaller subproblems once and reusing their solutions instead of recomputing.

There are two core properties that dynamic programming problems need to have:

Optimal Substructure: The answers to subproblems can be used to construct the final answer
Overlapping Subproblems: Same problem is solved multiple times (re-computing)

Solutions that can be found by breaking down into non-overlapping sub-problems are not considered dynamic programming but are instead divide and conquer.

Emacs

Sat, 24 Jan 2026 00:00:00 -0600

Embarassingly parallel

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Parallelism

Embarassingly parallel is a term used when a problem or workload where little or no effort is needed to split the problem into a number of parallel tasks.

Computer graphics rendering is one such example of this since each individual pixel does not need to know anything about its surrounding ones. All of this parallelism is achieved on the GPU, which is tailored perfectly for the task.

Fragmentation

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Virtual memory

Fragmentation is a concept in computer sciece that involves the distribution of data within a finite space. Memory needs to be structured in some way so that processes are unable to directly access memory from a different process.

There are two types of fragmentation:

External: Occurs when using segmentation. Space between segments becomes wasted. Can be solved by compaction, but this is expensive.
Internal: Occurs when using paging, because fixed size pages that aren’t full will inevitably waste spaces. Solved by having smaller pages, but that makes tradeoffs with the page table being larger.

Functional programming

Sat, 24 Jan 2026 00:00:00 -0600

Graphics programming

Sat, 24 Jan 2026 00:00:00 -0600

Habits

Sat, 24 Jan 2026 00:00:00 -0600

Habits are routine for us, they are the biggest indicator of what we will be doing in the long-term. They are hard to form and hard to break. Maintaining good habits decreases our reliance on willpower, a fleeting resource for humans. Habits also combat the conflict between long-term and short-term interests for us. Applying strong habits to learning and thinking will allow for a much greater understanding over time.

Hash table

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Data structure

A hash table is a data structure which utilizes a hash function to speed up lookups. There are two primary ways of building a hash table structure:

Separate chaining
Open addressing

Hash functions

Modulo (division) method hash(k) = k mod(m)
Multiplication method hash(k) = (a*k) mod(2^w) >> (w-r) where w is the word size of the machine and a is a random word, meaning a*k will be 2 words in length. Should be odd and not close to power of 2 m = 2^r in practice works quite well. Theoretically can perform worse
Universal hashing h(k) = [(ak + b) * mod(p)] * mod(m) a and b are large primes.

Perfect hashing

A perfect hash function h for a set S is a hash function that maps distinct elements in S to a set of m integers, with no collisions. In mathematical terms it is an injective function.

Header files in C++

Sat, 24 Jan 2026 00:00:00 -0600

Previous: C++

Header files in C++ are files that should contain all forward declarations of a source file. They are used to structure and create programs that span multiple files.

A clean header file implementation is subjective, but it should have at least the following to get started:

Header guard
Include additional headers and files that the header needs
Documentation about what the file does, and what each function can do.
Class and function declarations

Header files are not technically compiled, they are included via the preprocessor in the earlier stages of compilation.

Heap data structure

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Data structure

Heaps are the underlying data structure to priority queues and

Heap-order property: Root maintains the target with all elements being either larger or smaller than it depending on if its a min heap or max heap.

This is the most idiomatic way of creating a minimum heap in C++

std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap;

// Useful if there are pairs
std::priority_queue<
 std::pair<int,int>,
 std::vector<std::pair<int,int>>,
 std::greater<std::pair<int,int>>
> pq;

// There is also std::make_heap which will create a heap given iterators.

The heap is a tree like data structure that satisfies the heap property.

Homomorphism

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Category theory

A homomorphism is not an Isomorphism when it is not bijective, meaning it either:

Fails to be injective (one-to-one): This happens when different elements in the domain are mapped to the same element in the codomain. For example, the kernel of the homomorphism (the set of elements that map to the identity element in the codomain) is not trivial, indicating that the homomorphism is not injective.
Fails to be surjective (onto): This occurs when not every element in the codomain has a preimage in the domain. In this case, some elements of the codomain are not “reached” by the homomorphism.

Isomorphism

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Category theory

An isomorphism is a special kind of homomorphism, where structure is preserved through the mapping between two structures. This means all isomorphisms are homomorphisms, but homomorphisms are only isomorphic if they are also a bijection.

Lambda expressions in C++

Sat, 24 Jan 2026 00:00:00 -0600

Previous: C++

Lambda expressions, also known as lambdas or closures, were added in C++11 and refined further in later versions. They allow you to define an unnamed function object which can be nested inside of other functions.

Although lambdas behave a lot like functions, they are not functions themselves. The type of a lambda expression is a unique, unnamed, non-union class type generated by the compiler. Specifically, they define an overloaded function call operator (operator()), which makes them functors (also called function objects).

Lifetimes in Rust

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Rust

Lifetimes in Rust are a type of generic for validating references. Lifetimes are inextricably linked to references and the concept of borrowing.

Lifetimes are a crucial aspect of Rust’s memory management model that ties into borrowing. A lifetime specifies the scope for which a reference to a resource is valid. In Rust, the compiler uses lifetimes to ensure that references do not outlive the data they refer to, thus preventing dangling references. Lifetimes help the compiler understand how long a reference should be considered valid, and they need to be specified when the compiler cannot automatically infer the duration itself. This makes lifetimes a powerful—though sometimes challenging, tool for managing memory safely and efficiently.

Merge sort

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Sorting

Merge sort is a divide-and-conquer algorithm for sorting an array in O(n(log(n))) time complexity in both best and worst case. The space complexity is O(n) due to the extra copies needed for the merge routine.

The actual sort algorithm is quite simple: recursively halve the array until you are down to two single elements, and then merge the two halves.

The merge is a bit trickier to write: allocate two copies of the array, maintain 3 pointers, and compare values from the copies, placing them in the main array until they are exhausted.

Most vexing parse in C++

Sat, 24 Jan 2026 00:00:00 -0600

Previous: C++

The most vexing parse phenomenon is a syntactic ambiguity resolution that can stump unassuming programmers who have not encountered it before (and even those who have). It says that any statement that fits the criteria to be a function declaration will be.

For instance:

Widget f();

This piece of code may look like it is going to call the default constructor with no arguments, but it is instead declaring f() that returns a Widget. Direct initialization (using braces) can help prevent this.

Move semantics in C++

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Special member functions in C++

Move semantics were introduced in C++11 as an optimization for efficiently transferring ownership of resources between objects. Before their introduction, copying temporary objects would invoke copy semantics, resulting in an unnecessary deep copy of data, followed by destruction of the temporary.

C++11 clarified the distinction between lvalues and rvalues, enabling the implementation of move semantics. With the addition of rvalue references (`T&&`), the language gained the ability to identify temporary (expiring) objects and move their resources instead of copying them.

Nix

Sat, 24 Jan 2026 00:00:00 -0600

Nix is a language, package manager, and operating operating system (NixOS).

OpenGL

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Graphics programming

Operating system

Sat, 24 Jan 2026 00:00:00 -0600

Process

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Operating system

A process is possibly the most fundamental abstraction provided by the operating system. At its most basic level a process is simply a program that is being executed by CPU. Each process is given its own virtual address space which is its own abstraction for memory.

Process states

A process can be in one of three primary states:

Running: Actively having instructions executed by the CPU
Ready: Waiting for the CPU
Blocked: The process has initiated some operation which prevents it from being able to execute further instructions.

A scheduler can move a process between the running and ready states.

References in Rust

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Rust

Rules of references in Rust

At any given time, you can have either one mutable reference or any number of immutable references.
References must always be valid.

A reference in Rust never owns the value it points to; it only provides access to it. This ties references directly into Rust’s ownership system: borrowing values instead of transferring ownership. The act of creating a reference is called borrowing.

The borrow checker ensures that multiple immutable references can coexist, but a mutable reference must always be unique. This enforces Rust’s principle of immutability by default, consistent with `let` (immutable) and `mut` (mutable) bindings.

Rust

Sat, 24 Jan 2026 00:00:00 -0600

Shader

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Graphics programming

A shader is a small program that is specifically meant to be run on the GPU to take advantage of its massive parallel compute. There are many different kinds of shaders but the most often used for game development are the vertex and fragment shader.

These two both play massive parts in the rendering pipeline. The vertex shader runs upon the GPU receiving information such as vertex data from the application running on the CPU. The fragment shader runs later in the rendering pipeline and is purely responsible for coloring each of the pixels on the screen.

Vertex buffer object

Sat, 24 Jan 2026 00:00:00 -0600

Previous: OpenGL

A vertex buffer object (VBO) is OpenGL’s way of uploading vertex data to the GPU.

Why titles matter in a Zettelkasten

Sat, 24 Jan 2026 00:00:00 -0600

Previous: Zettelkasten

Titals are vital to a Zetelkasten, specifically, specific ones. If a title is too vague, then it isn’t of very much use to the user. If you cannot tell what the contens of a note are based off the title, then it is named poorly. There is nothing wrong with long and descriptive titles when creating notes; it is better to be overly specific than not specific enough.

The two biggest benefits to specific note titles:

Zettelkasten

Sat, 24 Jan 2026 00:00:00 -0600

A Zettelkasten is a system for taking notes in a style originally developed by Niklas Luhmann. It involves the creation of many small notes which can be linked together, much like the internet and webpages.

Vertex array object

Thu, 15 Jan 2026 00:00:00 -0600

Previous: OpenGL

A vertex array object (VAO) is the means or context for which the GPU should parse the Vertex buffer object. It defines things like positions, textures, and other information. It ties together the buffer with the actual layout of the data.