(Published: 2026-01-07)

2026 Roadmap and Goals

“The important thing is not your process, the important thing is your process for improving your process.” — Henrik Kniberg, on the continuous nature of self-improvement.

Happy new year to everyone around the world! I hope you too have had a lovely break from the whiny PM’s this past week or two, and enjoyed your holidays. A new year marks renewed excitement, hopes, and challenges. It is also a chance to reflect on the past 12 months and set concrete goals for self-improvement.

In that spirit, I want to take this opportunity to spell out some objectives I had in mind that I am aiming to achieve in this Year of the Horse. By doing so, I want to keep myself accountable so that I can revisit these objectives quarterly and do a final retrospective at the end of the year.

TL;DR (in no particular order):

• Revamp website (already WIP)
• Career boosts
  • Get promotion or paybump at my job
  • Finally do Kubernetes CKA certificate
  • Learn Rust?
• Side hustles
  • Get notmuch.nvim to 100+ stars
  • Roll out my own pkm system for notetaking and task management
  • Launch app startup
• Blog more
• Nixify homeserver (and Macbook?)

🚧 Revamp website

(This is already in progress).

I first created and deployed this microblog site in late 2024 as an exercise for me to get into blogging, journalling, and sharing cool things I’ve learned as a lens for my future self.

I’m no web dev, so naturally I prioritized a simple, static, stupid design with monospace fonts and hilariously basic HTML/CSS tricks here and there. I even built tiny bash scripts: a pandoc wrapper for turning blog posts from markdown to HTML; an rssgen script to generate, update, and publish my RSS feed. All of the site code, of course, tracked with git on my remote VPS with a post-receive git hook to deploy it to /srv.

It’s about time that I revisit this site and make it more presentable to people online. I think of it as my digital version of cleaning up my room, bucko (🐸).

Some wishlist items on my agenda for tangible differences:

• Settle on a more elegant and readable font-face across the site
  • Poppins for sans-serif, and Jetbrains Mono for code
• Clean up typesetting with consistent sizing, emphasis, weights, etc.
• Upload my gpg key so that people can download it and verify my emails and git commits
  • Check it out here
• Fix code blocks everywhere, especially my previous blog posts
  • Syntax highlighting
  • Fix code display issues from pandoc generation
  • Add copy button
• Blog system revamp
  • Generate an index of blog posts and tags
  • Searchable
  • Reading time estimates
• More to come…

💼 Career kaizen

Self-improvement is a foundational pillar in my life. I’m allergic to feeling stale and behind, and am constantly looking for ways to improve my career trajectory. I enjoy it because I’m genuinely passionate in this field. Learning things like DevOps and system design feels like gymming for my brain.

One of my favorite feelings is being able to apply skills and certification knowledge directly in my job as I have done for the past 4-5 years: DevSecOps, Cloud computing, AI (basic stuff), PowerBI, and more. Apart from the job clout it gives, this feedback loop is really fulfilling and gives meaning and purpose to my role as Solution Architect.

💰 Chase the corporate bag

I’ve been employed at my current job for about 4.5 years now (CV). I started out as a junior/trainee engineer (solutions architect role), and got promoted to “Senior Engineer” in Feb 2023.

Since then, my role, impact, and scope as an engineer has grown vastly. This year alone, I’ve achieved these milestones apart from growing organically as an engineer:

• Became a lead SPOC DevSecOps engineer, integrating all systems/applications in our tech stack into our GitLab for automated CI/CD.
• Delivered 93+ change requests (1-3 month SLA) – the highest in my team.
• Delivered hundreds of business-as-usual (BAU) requests (1-3 day SLA).
• Improved our department role’s business impact and value with PowerBI dashboards for operational monitoring post-go-live.
• Spearheaded group-led AI initiative in our DevSecOps ecosystem with GitLab Duo (first in the region).
• And more…

With this expanding role and ever-growing list of responsibilities (I consider myself as doing multiple job descriptions), as well as recent layoffs in our team (we are down to two engineers – yikes), I think it’s high time to negotiate a better compensation package.

Starting this year with a bang, I’m demanding getting a better pay grade, otherwise I’m looking elsewhere because this volume of work is not sustainable for what I’m currently being paid in the long run – especially if you consider the additional workload we’re anticipating this year, my excellent performance last year, and my marital situation now.

🐳 Finally complete CKA certification

Last year I started my journey into learning Kubernetes. Like any other well-guided certification path, I aimed to get CKA certified to enrich my role as a GitLab DevSecOps lead engineer, and staying ahead of the curve as our infrastructure is moving more and more towards containerization (specifically with RedHat OpenShift).

Alas, life hit me in the face and I fell in love 😅. Marriage and its obligations made me re-structure my life and priorities. My better half, of course, took precedence. Fortunately, since things are settling down and I am getting back into my groove and routine, I have the opportunity to kickstart my learning journey back up and pursue this certification.

My goal is to get CKA certified by end of Q1 this year. To keep myself accountable, I will be blogging about the journey here.

🦀 Learn Rust

Last year I made a concentrated effort at learning Go. I built multiple tools specifically in Go such as o, the Obsidian CLI wrapper and pkm, my personal knowledge management tool. Even the backend for the app startup I’m working on, KuwaitCare, is written in Go.

I’ve gained a lot of skills and knowledge by focusing so much of my effort on learning the programming language through a mix of theory and project-driven practice with real-world applications that put that knowledge to the test:

• Test-Driven Development (TDD)
• Error as a first class citizen of a lanugage (error handling in general)
• Building TUIs with Charmbracelet’s BubbleTea framework
• Building full-scale backend systems with routing, middleware, JWT authentication, RBAC authorization, rate-limiting, DB interfacing, and packaging it with Docker (for k8s in the near future)

Building on that momentum, I want to use that same project-driven learning methodology to the next programming language/framework that has been on my radar for a long time: Rust.

I won’t jump into it blindly. I want to wait for project ideas to come to me first that I can use as an opportunity to learn and apply knowledge into Rust.

Ideas are welcome! I’m mostly anticipating another CLI/TUI tool to implement. Perhaps something to do with homeserver management or similar.

👨‍🚀 Side hustles

This year I want to focus more of my free time on open-source projects I have and side projects I have going on. Some of my open source projects have gone stale over time and collected dust in the form of Issues and PR’s on GitHub. However, I’ve made sure to clean those up recently over the past month or two and I have seen a significant uptick in their traffic, so it would be a shame not to capitalize on the moment to build something real and useful to the community.

⭐ Get notmuch.nvim to 100+ stars on GitHub

I wrote my Neovim plugin, notmuch.nvim, back in 2021 during COVID to turn my favorite text editor into a Mail User Agent (MUA) with basic features.

I left it stale this time last year with a very early release of v0.1.0 with humble and basic features for reading and sending email from within nvim. Over the past few months it accrued some issues and feature requests which I have recently tended to.

Now it is in a really promising position in its early stage where it can be built into a fully featured mail client with tons of nvim related features like inspecting, searching, tagging, sending with attachments, etc. and I am really excited to see it to its full potential.

I am already working on a v0.2.0 release with the following wishlist:

• Tons of new features added
  • Examples…
• Add a CHANGELOG and semantic versioning for community friendly collaboration and updates
• Publish more documentation
• Publish FAQs for notmuch/Maildir related topics
• Record and publish a demo video showcasing the plugin and its features
• Announce to Reddit and other boards for more traction

The main goal here for this year is to get this plugin up to 100+ ⭐ stars on GitHub (it’s currently at 44 as of writing this blog post).

📝 Roll out pkm first release

What better way to learn a programming language (in this case Go) than to implement yet another to-do list manager and notetaking system? I wrote pkm to make a “chronological journalling” system where I can externalize my thoughts and view projects and their evolution over time through the axis of notes over time.

The time component is not to be understated at all. For knowledge workers like myself, our work environment demands that we adapt dynamically to rapidly changing requirements and decisions from every channel: meetings, one-on-ones, emails, informal conversations, overheard insights, etc.

For that reason, I sought to make this CLI (and TUI) app to better streamline the influx of information in the superhighway that is knowledge work. Its main idea is to allow you to “view” a project/topic/tag by displaying a list of notes (gathered information) over time to better track its evolution.

I won’t go into too many details, or get too dramatically philosophical, so let me cut to the chase here: if you are familiar with Tiago Forte’s 4 Notetaking Styles, this app follows the “Architect” notetaking style.

I’m planning on releasing a public version of this app soon that hopefully resonates with people with this idea of time-based knowledge organization.

📱 Launch KuwaitCare app startup

This one’s a slow burner. For a couple of years now I’ve wanted to launch an app startup here in Kuwait to provide an app solution for healthcare/selfcare businesses and their customers. KuwaitCare is essentially a booking reservation system offered for self-care establishments (clinics, spas, barbershops, etc.).

Today these businesses rely on Instagram DM’s to handle reservations, bookings, questions, etc. This opens up the opportunity of bad faith business in many ways:

• Shady impersonator “business” accounts stealing customer info or funds
• Businesses can’t verify authenticity of customer from social handles
• Customers have no gauge of the business due to lack of review system
• No booking timesheet available, it’s all guesswork
• Double booking galore
• And so much more…

This app I’m building is aimed at bridging this gap in the market to provide a comfortable and seamless experience for both customers and establishments in the self-care space, which is a booming market here.

I really want to get this thing to the finish line and complete a first MVP for it. So far I’ve implemented many huge milestones (mainly on the backend) and I feel I need to focus much more on the look and feel this year to get this pushed out to store.

❄️ Nixify my homeserver

A year or two ago, I took one of my old gaming PC’s hostage, shoved it in my basement right next to the main home router, installed Ubuntu Linux, and turned this old PC into a glorified homelab/homeserver.

Currently I run a few really awesome self-hosted services on it:

• ☁️ ownCloud for self-hosted cloud storage (De-Google!)
• 🏴‍☠️ Transmission BitTorrent client
• 📡 CommaFeed self-hosted feed reader
• 📺 Jellyfin Plex-like self-hosted content streaming

I also use it as a convenient testbed for many projects that I work on. With Docker and Kubernetes installed on it, it doubles as a useful tinkering tool and cluster.

One of the things I want to learn this year is Nix, the declarative language, operating system, package manager, and system configurator.

As mentioned before, I learn the most through practical projects where I can get my hands dirty and apply my skills. This is no different.

So, I am planning to install NixOS on my homeserver to turn my messy homeserver into a reproducible, version controlled, declarative machine.

👨‍💻 Blog more

This blog post takes the first step in doing so. I really enjoy the process of blogging and sharing my thoughts online, even though I don’t know (or care) who reads this.

I already have a backlog of things I would love to write about. But on top of that, I’d like to use this microblog to document my journey – not just in progress updates for the above points, but also in sharing guides, issues and fixes, frustrations, general journalling/logbooking, capturing travel moments, and so much more.

A solid metric: I should keep a tangible goal of writing at least 1 blog post per month, as a goal to stick to this year.

💭 Final thoughts

If you reached this far, I really appreciate the time you took and hope I gave some cool insight into my life. Who knows, maybe this motivates you to start your own blog or personal roadmap to keep yourself accountable.

Here’s to a beautiful new year filled with exciting moments!

(Published: 2025-08-30)

Changelog:

(2025-08-30): Published initial version

(2025-12-14): Fixed for loop missing in keyword

Here is a compendium of reference information regarding bash (also applies to zsh) for syntatic sugar that I keep finding myself googling. I’d much rather keep these handy with me offline to make sure I’m always prepared for quick shell scripting or issuing complex commands on the go.

if-else Statements

The typical if-else statement in bash looks like this:

if [ condition1 ]; then
    # commands to execute if condition1 is met
elif [ condition2 ]; then
    # commands to execute if condition2 is met
else
    # commands to execute if none of above conditions are met
fi

Conditional Operators

Here are common conditional operators that are used in condition checks

File Operators

These are operators used to check on files

• -e: checks if file exists
• -f: checks if regular file
• -d: checks if argument is a directory
• -s: checks if file is non-empty
• -r: checks if file is readable
• -w: checks if file is writable
• -x: checks if file is executable

Keep in mind that these operators are not stackable. If you want to check if a given file is both readable and writable, you would do something like this:

if [ -r "filename.txt" ] && [ -w "filename.txt ]; then
    # file is both readable and writable
fi

String Operators

These are operators used to perform checks on strings

• string: true if the length of string if non-zero
• == / = : true if both string operands are equal
• !=: true if the string operands are not equal
• <: true if string1 sorts before string2 lexographically
• >: true if string1 sorts after string2 lexographically
• -eq, -ne, -lt, -le, -gt, -ge: string arithmetic checks

Case Statement Syntax

case EXPRESSION in
    PATTERN1)
        COMMANDS1
        ;;
    PATTERN2)
        COMMANDS2
        ;;
    # ...and so on...
    *)
        DEFAULT_COMMAMDS
        ;;
esac

Loops

There are multiple types of loops in bash scripting depending on the use case

for Loop

You can do list-based iteration like so:

for variable in item1 item2 item3; do
    # commands to execute for each item
    echo "Reference item with: $variable
done

Or you can do range-based iteration:

for i in {start_idx..end_idx[..increment]}; do
    # commands to execute
    echo "Current number: $i"
done

Note: C-style syntax also works

for (( i=start; i<=end; i++ )); do
    echo "Current number: $i"
done

while Loop

This loop runs commands until the condition is no longer met (no longer true)

while [ condition ]; do
    # Commmands to execute
done

Note: You can use the same conditional operators as seen in the if-else section

until Loop

This loop runs in the inverse logic of the while loop. It runs until the condition is met (becomes true).

until [ condition ]; do
    # Commands to execute
done

Note: You can use the same conditional operators as seen in the if-else section

Parameter Expansion

When invoking parameters and variables in shell scripting, you may need to transform or manipulate the content in some ways:

Basic Expansion

Simple substitution ivolves using $paramter or better yet ${parameter} to substitute the content of the variable in place.

myvar="hello world"
echo "${myvar}" # output: hello world

Default Value

You can give a default value for safety if a parameter/variable may be empty

${paramater:-default} # uses "default" if `parameter` is unset or null
$(parameter:=default} # same as above but assigns "default" to `parameter`
${parameter:?default} # displays "default" as an error message and exits if unset
$(parameter:+default} # uses "default" if `parameter` is set and not null

String Manipulation

You can use the following categories of manipulation on strings to manipulate and transform the output if you want a subset of the string only

Substring Manipulation

${parameter:offset} # extracts substring from `offset` (int)
${parameter:offset:length} # extracts substring of length `length` from `offset` (int)

Remove Prefix

${parameter#pattern} # removes the shortest match of `pattern` from the beginning
${parameter##pattern} # removes the longest match of `pattern` from the beginning

Remove Prefix

${parameter%pattern} # removes the shortest match of `pattern` from the end
${parameter%%pattern} # removes the longest match of `pattern` from the end

Replace Substring

${parameter/pattern/string} # replaces the first match of `pattern` with `string`
${parameter//pattern/string} # replaces all matches of `pattern` with `string`

Case Modification

${parameter^pattern} # converts the first character of the matched pattern to uppercase
${parameter^^pattern} # converts all characters of the matched pattern to uppercase
${parameter,pattern} # converts the first character of the matched pattern to lowercase
${parameter,,pattern} # converts all characters of the matched pattern to lowercase

Indirect Expansion

${!parameter} # uses the value of `parameter` as the name of another variable

(Published: 2024-10-14)

Hash Fast, Bash Smart

hash is a useful built-in shell command used for caching commands/executables from your $PATH variable. This helps bash/zsh avoid having to rescan your PATH each time you enter a command during the find and execution process.

This command is great for resetting/regenerating the PATH commands cache with the -r flag. For example, python3’s virtualenv uses this to manage your command cache after activating and deactivating your virtual environment.

hash -r 2> /dev/null

This snippet runs hash with -r flag to “reset” the commands cache. Error/logging is discarded to /dev/null for quiet execution.

Note: Running hash alone just prints out the current command cache list

Use Cases

• (Shown above) Quickly recaching your commands after (de)activating virtualenv
• Moving, renaming, or deleting a command: Reflect its non-existence with -r
• Installing a package/binary: Quickly recache to shell with hash -r
• After adding a new directory into PATH and wanting to index its commands

To learn a bit more about hash, check out the bash manual entry.

(Published: 2024-11-22)

Moving from X to Bluesky

As of today, I’m officially moving away from X (formerly Twitter) and joining Bluesky instead.

Reasons for moving

The main reasons I did this are the following:

1. X is just way too toxic.

Everyone (okay, not every single person) there is looking for a fight CONSTANTLY. After a while it just gets too tiring and draining.

2. Too much NSFW content.

The platform is littered with “sex tapes” and “leaked scandals”. Hell, I can’t even open a post without being bombarded with promoted ads that are NSFW.

inb4 iT’s yOuR aLgOriTHm BrO, iT aDjUsTs tO yOuR pReFeReNcEs hurr.

3. Bot situation is out of control.

There is no sort of regular discussion anymore. Replies to posts are filled with nonsensical content promoting irrelevant memecoins, scammy courses, and attention-seeking social-engineering bots. It all feels fake and plastic.

4. Misinformation

The last U.S. election was a damning red flag fest, with the amount of casual misinformation and fake news posted unfettered. Sure, community notes are there, but it’s not helpful when the BDFL of X casually posts fake news on the regular and the damage is already done.

Elon’s toy project does not spell well for the future of Internet users. It is now a disservice to humanity, in my opinion.

Follow me!

Anyway, come join and you can follow me on Bluesky if you like my content and want to connect. I’d love to see more people join. Make sure you come say hi! :-).

Yousef on Bluesky

(Published: 2024-10-17)

Introduction

Today marks the kick off of the SAP Multi-Dimensional Engineer Program (MDEP) where engineers who passed the selection process are onboarded to the program.

We received introductions to the mentors, the program, and the curriculum we will be expected to learn in the next two months.

Below is the notes I took during the meeting for future reference.

Overall I am super proud and excited to be in this program. It looks super insightful, and aligns exactly with my ambitions of empowering not only my technical skills, but also my soft skills to better myself as an engineer.

Multi-Dimensional Experience

• Program is specially designed for mixing top-notch technology skills with social and soft skills.

• Pushes you out of your comfort zone to instill a real lasting education.

• Explore Silicon Valley culture.

• Exclusive opportunities to visit institutions and universities and bright minds.

• Opportunity to network and build ties in the community.

Program Structure

The program has 5 phases:

Selection -> [Kickoff] -> Self learning phase -> In person phase -> Graduation

• 2 months of Hybrid Learning Experience
  • Phase 1: 1 month of self learning phase
  • Onboarding workshop in Riyadh (Bring laptop with you)
  • Phase 2: 1 month of in person learning full time in the USA

TODO: Apply for visa as soon as possible

MDEP Curriculum

As mentioned, the MDEP is split into two halves of the curriculum: technical and soft skills.

Technology Stack

• SAP products overview: S4 HANA, SuccessFactors, Business Networks, and more
• SAP Business Technology Platform
• SAP analytics Cloud
• Application Development using SAP Build, SAP CAP
• Machine Learning and GenAI
• Agile Methodology
• Cybersecurity
• UX Design
• First principles thinking & systems thinking

Multi-Disciplinary Stack

• Cross cultural intelligence
• Purpose Driven Leadership
• Effective Storytelling and Communication
• Personality assessment workship
• Thought leadership sessions
• Community building and hackathon
• Art of Journaling and Reflections

Self Learning Topics

The technology stack self-learning takes about 24 hours to complete in total.

• NodeJS (8 hours)
• SQL (4 hours)
• ERP Business Process (12 hours)
• Hackathon for testing our skills and teamwork.

Digital Badges and Completion Certificates

• Digital Badge (LinkedIn and other social media)
• Graduation Certificate (Hard copy certificate of completion)

Important Updates

• Apply for VISA ASAP.
  • B1/B2 visa.
• COVID Protocols.

(Published: 2024-11-15)

SQL Self Training Notes

This is the self learning phase notes of the SQL database management system language.

You can consider this is a compilation of basic, intro-level notes to SQL. It is not comprehensive nor is it “in-depth”.

If you feel there is anything missing, wrong, or worthy of addition, please feel free to reach out and open a discussion.

The link to the training is found below:

SQL and Databases - A Full Course for Beginners

Material Covered

Broadly speaking, it will cover: Schema design, Create-Read-Update-Delete operations (CRUD), and database fundamentals.

• What a database is
• Tables and Keys
• SQL Basics
• MySQL Windows/Mac Installation
• Creating Tables
• Inserting Data
• Constraints
• Update & Delete
• Basic Queries
• Company Database Intro
• Creating Company Database
• More Basic Queries
• Functions
• Wildcards
• Unions
• Joins
• Nested Queries
• On Delete
• Triggers
• ER Diagrams

What is a database

A database is any collection of related information like a phone book, shopping list, todo list, user base, list of transactions.

We typically store these in computers using a relational database. We use a structured query language (SQL) to interact with that database.

Database Management Systems (DBMS)

Special software program that helps users maintain a database.

Handles managing large amounts of information, security, backups, importing/exporting, concurrency, etc.

C.R.U.D. Operations

Performs the CRUD operations:

• Create
• Read
• Update
• Delete

Types of databases

Relational Dabatabases (SQL)

Organizes data into tables with rows and columns

Rows are identified using unique keys.

Examples:

• mySQL
• Oracle
• PostgreSQL
• MariaDB

Non-Relational Dabatabases (Non-SQL)

“Anything but a traditional table”

Organizes data in less structured form.

Typically uses things like key-value stores (JSON), Documents, Graphs, etc.

Examples:

• MongoDB
• DynamoDB
• Apache Cassandra
• Firebase

Implementation specific: Each implementation uses its own DBMS to handle its own storage structure

Database Queries

Queries are simply requests made from a user of application to the database management system asking for speicific information matching a criteria.

Tables and Keys

Surrogate Key

A unique key which has no real world meaning or value (e.g. randomly generated, unique, number to identify employees).

Natural Key

A unique key which has real world mapping (e.g. employee SSN, or citizen national ID number).

Foreign Key

A attribute key which is used to link one table to another table. A foreign key is considered a primary key for the table that it links to.

Composite Key

A unique key that is made up of 2 or more attributes (ie. ID + name).

SQL Basics

SQL is a language used for intercting with Relational Database Management Systems (RDBMS).

SQL is a hybrid of 4 types of languages:

• Data Query Language (DQL)
  • Query database for information
• Data Definition Language (DDL)
  • Defining database schemas
• Data Control Language (DCL)
  • Controlling access to the data in the database
• Data Manipulation Language (DML)
  • CRUD manipulation for updating database entries

Queries

A query is one or more criteria given to the RDBMS as an instruction to retrieve specific information from the database

Data Types

• INT
• DECIMAL
• VARCHAR(l) : String of length l
• BLOB : Binary large object, stores large data
• DATE : YYYY-MM-DD
• TIMESTAMP : YYYY-MM-DD HH:MM:SS

Keywords

• DEFAULT for default values
• AUTO_INCREMENT for setting PK without explicitly typing
• NOT NULL does not allow empty values
• UNIQUE prevents duplicates

Primary key is essentially just an INT with both UNIQUE and NOT NULL properties

UPDATE

To update values of rows in the table:

UPDATE student
SET major = 'Biochemistry'
WHERE major = 'Bio' OR major = 'Chemistry'

DELETE

To delete a certain row/entry from a table:

-- Deletes all entries where name is 'Tom' with undecided major
DELETE FROM student
WHERE name = 'Tom' AND major = 'undecided'

-- To delete all entries from the table
DELETE FROM student

SELECT

Retrieve all rows in the table:

-- Retrieves all columns from the `students` table (all entries)
SELECT * FROM student;

-- Select only the id and name in alphabetical order
SELECT student_id, name
FROM student
ORDER BY name DESC;

Company Database Example

Questions

Difference between:

ON DELETE SET NULL
ON DELETE CASCADE

In this tutorial chapter we set up the company database for the office with the tables for employee, branch, client, works_with, and branch_supplier.

-- Employee table
CREATE TABLE employee (
    emp_id INT PRIMARY KEY,
    first_name VARCHAR(40),
    last_name VARCHAR(40),
    birth_day DATE,
    sex VARCHAR(1),
    salary INT,
    super_id INT,
    branch_id INT
);
DESCRIBE employee;
SELECT * FROM employee;

-- Branch table
CREATE TABLE branch (
    branch_id INT PRIMARY KEY,
    branch_name VARCHAR(40),
    mgr_id INT,
    mgr_start_date DATE,
    FOREIGN KEY(mgr_id) REFERENCES employee(emp_id) ON DELETE SET NULL 
);
DESCRIBE branch;
SELECT * FROM branch

-- Add branch_id foreign key to employee
ALTER TABLE employee
ADD FOREIGN KEY(branch_id)
REFERENCES branch(branch_id)
ON DELETE SET NULL;

ALTER TABLE employee
ADD FOREIGN KEY(super_id)
REFERENCES employee(emp_id)
ON DELETE SET NULL;

-- Client table
CREATE TABLE client (
    client_id INT PRIMARY KEY,
    client_name VARCHAR(40),
    branch_id INT,
    FOREIGN KEY(branch_id) REFERENCES branch(branch_id) ON DELETE SET NULL 
);
DESCRIBE client;
SELECT * FROM client;

-- Works_with table
CREATE TABLE works_with (
    emp_id INT,
    client_id INT,
    total_sales INT,
    PRIMARY KEY(emp_id, client_id),
    FOREIGN KEY(emp_id) REFERENCES employee(emp_id) ON DELETE CASCADE,
    FOREIGN KEY(client_id) REFERENCES client(client_id) ON DELETE CASCADE
);
DESCRIBE works_with;
SELECT * FROM works_with;

-- Branch supplier table
CREATE TABLE branch_supplier (
    branch_id INT,
    supplier_name VARCHAR(40),
    supply_type VARCHAR(40),
    PRIMARY KEY(branch_id, supplier_name),
    FOREIGN KEY(branch_id) REFERENCES branch(branch_id) ON DELETE CASCADE
);
DESCRIBE branch_supplier;
SELECT * FROM branch_supplier;

-- Insert Corporate office employees
INSERT INTO employee VALUES(100, 'David', 'Wallace', '1967-11-17', 'M', 25000, NULL, NULL);
INSERT INTO branch VALUES(1, 'Corporate', 100, '2006-02-09');

UPDATE employee
SET branch_id = 1
WHERE emp_id = 100;

INSERT INTO employee VALUES(101, 'Jan', 'Levinson', '1961-05-11', 'F', 110000, 100, 1);

More Basic Queries

• SELECT <attributes> vs. *
• SELECT <attribute> AS <alias>
• SELECT DISTINCT <attribute>
• ORDER BY
• LIMIT

Functions

• SELECT COUNT(<attribute>) to find number of entries there are
• SELECT AVG(<attribute>) to find the average of entries
• SELECT SUM(<attribute>) to find the sum of entries
• GROUP BY <attribute> to aggregate function results by attribute

Wildcards

• % = any
• _ = one character
• LIKE

-- Find any clients who are an LLC
SELECT *
FROM client
WHERE client_name LIKE '%LLC';

-- Find any employee born in October
SELECT *
FROM employee
WHERE birth_date LIKE '____-10%';

Union

Union

A special operator used to combine the result of two or more search criteria.

-- Find a list of employee first names and branch names
SELECT first_name
FROM employee
UNION
SELECT branch_name
FROM branch;

> Note: Unions assert that each combined criteria is using the same number of > columns in the SELECT part

Joins

Join

Operator used to combine rows from two or more tables based on a related attribute between them

-- Find all branches and the names of their managers
SELECT employee.emp_id, employee.first_name, branch.branch_name
FROM employee
JOIN branch
ON employee.emp_id = branch.mgr_id;

LEFT JOIN

Includes all entries in the LEFT table (FROM <table>) in the output of the JOIN

RIGHT JOIN

Includes all entries in the RIGHT table (JOIN <table>) in the output of the JOIN

Nested Queries

Using multiple SELECT statements to get specific information.

Nest another SELECT statement after WHERE statement

-- Find names of all employees who have sold over 30,000 to a single client
SELECT employee.first_name, employee.last_name
FROM employee
WHERE employee.emp_id IN (
    SELECT works_with.emp_id
    FROM works_with
    WHERE works_with.total_sales > 30000
);

On Delete

Determines how deleted entries update onto other tables with foreign keys.

SET NULL

When one entry is deleted, it sets the foreign key in other tables pointing to that entry to NULL.

CASCADE

When one entry is deleted, it also deletes the entries in other tables where the deleted entry is the foreign key.

Typically, we use CASCADE when the foreign key is part of the primary key for the relevant table (because a primary key cannot have a NULL value).

Triggers

A piece of code that defines a certain action that should occur when another event/operation takes place.

DELIMITER $$
CREATE
    TRIGGER my_trigger BEFORE INSERT
    ON employee
    FOR EACH ROW BEGIN
        INSERT INTO trigger_test VALUES('added new employee');
    END$$
DELIMITER ;

Entity Relationship (ER)

ER diagrams are a way to visually map out the schema, the relations between its tables and attributes.

Entity

Object we want to model and store information about

Attributes

Specific pieces of information about an entity. These are going to be the attributes or columns in tables

Primary Key

Attribute taht uniquely identify an entry in the database table

Composite attribute

Attribute that can be broken up into two or more sub-attributes

Multi-valued attribute

An attribute that can have more than one value

Derived attribute

Attribute that can be derived from other attributes. Does not go into the actual table but is used for visual convenience

Relationships

Defines a relationship between two entities to describe how they relate. Denoted by “Takes” or “Taken by”

Cardinality

1:1, 1:N, N:M referring to how the relationships act (ie. one side is connected to many of another side, etc.)

Weak Entity

Entity that cannot be uniquely identified by its attributes alone. It needs to be expressed using attributes of another entity as well

Mapping ER to Schema

1. Mapping regular entities entity types -> Create tables

2. Mapping of weak entity types -> Create a relation table

3. Mapping of binary 1:1 relationship types -> Foreign keys

4. Mapping of binary 1:N relationship types -> 1 sides PK as FK of N side

5. Mapping of binary N:M relationship types -> Create a new table whose PK is combination of each side’s PK

(Published: 2026-02-10)

Terminal Image Display with WezTerm

For the longest time I’ve been struggling with image display in terminals. I either never bothered to put in the effort to configure it, or I was in config hell trying to figure out which program or layer was blocking the image display.

Now that I’ve ditched Ghostty and went back to WezTerm (I am so glad I did this, but that deserves its own blog), I finally got a working terminal setup with image display both with and without tmux.

Here’s how I did it, and some notes for reproducibility.

WezTerm built-in command

WezTerm has the wezterm CLI command for interacting with the terminal. This command includes a built-in imgcat subcommand that outputs an image to the terminal. This subcommand also respects tmux passthrough with an option flag.

Custom script

I created the following script for printing image output to the terminal, both within tmux and outside of it:

#!/usr/bin/env sh

# Script name: `img`

if [ -n "$TMUX" ]; then
    wezterm imgcat --tmux-passthru detect --max-pixels 2000000 "$@"
else
    wezterm imgcat "$@"
fi

Note: The max-pixels makes it so that tmux doesn’t have issues displaying large or high resolution image files (this happened a lot.)

Config

This config line is needed for WezTerm to enable the kitty image display protocol and allow for images to be displayed using escape sequences.

-- Required for reliable image rendering
config.enable_kitty_keyboard = true

File manager previews

I wrestled for hours with ranger and lf with no luck because they were all really hacky and error-prone.

Come to find out, yazi works like a charm out of the box because it already speaks the kitty image display protocol. No extra configuration needed, and it works in tmux without even needing to use the img script I showed above.

Cherry on top

Just to make things even smoother with yazi, I added PDF image previews in the terminal which requires poppler to be installed. Very straight forward install with brew.