My requirements while searching were the following:

• Reasonably priced with no recurring subscriptions
• Did not care much for a watch face or telling the time
• Lightweight and out of my way
  • No notifications or bright screen
• IMPORTANT: data ownership and exportability (more on that below)
• Long battery life
• Good sleep tracking
• Accurate enough

Price

The Fitbit Air sits at a very attractive price point ($99), and it is a one-time fee. In contrast, the WHOOP is priced higher and includes a yearly subscription fee with multiple membership tiers.

The Fitbit does have a paid tier as well, which adds on personalized coaching with Gemini, adaptive plans, sleep guidance, etc.

You can essentially replicate some of the data analysis and personalized monitoring by self-hosting your own health data using vitald, since your data is not vendor-locked and can be extracted from the Google API.

Look and feel

No complaints whatsoever here. The design of the Fitbit is sleek, subtle, and super light. Oftentimes I forget I am even wearing it, and that makes sleeping with the Fitbit on very comfortable.

It comes in three color options: black, red/pink, and blue. I picked the first, and it works well for most occasions whether you’re going for a sporty look or business-casual.

Not much more to say on that. It’s a very simple-looking device, and I like that.

Battery life

Compared to the Apple Watch I previously used, the Fitbit Air’s battery life is excellent.

Charging to 100% takes around an hour, and fully charged it lasts me about a full week. For reference, I was used to charging my Apple Watch nightly, which meant I pretty much always lost out on sleep tracking. I usually top it up while showering rather than waiting for the battery to run out, so charging rarely feels disruptive.

The device vibrates and briefly pulses a red light when the battery falls below 20%, and you get a notification on your phone as well to remind you.

To check the battery you can see the percentage on the Google Health app, or you can tap twice on the strap tracker. However, I find the double-tap gesture unreliable; it often takes several attempts before it works.

Health metrics

This device captures most of what I need in terms of health metrics:

• Steps
• Distance moved
• Sleep
  • Duration
  • Score
  • Breakdown of sleep stages (light, deep, REM)
• Heart rate
  • Resting heart rate
  • Heart rate variability
• Calories burned (roughly)
• Exercise
  • Track sessions with the Google Health app
  • Set targets for exercise streaks
  • Weekly cardio percentage
• Blood oxygen (SpO2)
• Skin temperature
• Readiness (recovery) score

It covers pretty much everything I need from a casual fitness tracker.

Accuracy in everyday use

I would give the accuracy a rating of 7.5/10.

Sleep detection has been particularly reliable in my experience. It generally figures out when I have fallen asleep and when I fully wake up. It’s easier to know if sleep metrics are right based on your awareness of how long you slept and how you feel after you wake up.

Similarly the heart rate metrics seem consistent with my experience on the Apple Watch and they are sufficiently accurate. I haven’t compared either device against clinical equipment, so this is a subjective affirmation.

With other metrics - such as calories burned, exercise intensity, readiness, etc. - it’s harder to judge because these devices make estimates based on height, weight, and other factors. Therefore, this is an assessment of everyday consistency rather than medical accuracy.

That said, my own observation of calories in/out vs. daily weight trend seems pretty reasonable (I’m maintaining weight at the moment). It’s not a validation on the accuracy, but more so an affirmation that it works for me.

Integration

Since Fitbit is now Google-owned, the ecosystem pairs very well with the Google Health app for a general view of your metrics.

As I hinted earlier, you also get to export your own data through the Google API and that kind of data ownership I was missing with the Apple Watch and it was a critical factor in this purchase.

Note: Technically Apple Health supports complete XML export as well through HealthKit. The advantage of the Fitbit is the convenient server-side API access.

In fact, I recently rolled out my own self-hosted data aggregation and health monitoring dashboard solution vitald. It’s a systemd-compatible service that periodically pulls my health data, backs it up, stores raw archives, normalizes the data into a Postgres database, and connects it to Grafana for visualization and monitoring. You can read my devlog on how I built it and how you can do the same.

Fitbit also gives you the ability to connect it to gym equipment (although I have not used this feature) to integrate data with it both ways.

That makes it a 9/10 on integrations.

Alarms

One thing I really liked about the Apple Watch is that I could use watch-like features (duh) with it like alarms, timers, and stopwatches.

It’s a bit of a regression with the Fitbit: it only has an alarm feature (you can set up to 9 alarms), and they activate with haptic feedback. The lack of timers and stopwatches makes sense, though, since there is no watch face to it; it’s just a strap, so I knew what to expect.

The haptic feedback is configurable with intensity. At the highest intensity, the vibration is strong enough to wake me up from sleep. Although the gesture to turn it off is really cumbersome and unreliable (tap twice really hard on the strap crown).

This gets a 6.5/10. Could be better in my opinion if silencing it was more convenient with a small button or a more reliable gesture.

Verdict

Overall, I’m very happy with this purchase and I really think it was worth the price for what it’s capable of and the data ownership it provides. The battery life is excellent and it gets out of your way. The auto-detection of activities is a really nice touch too if you can’t be bothered to log them beforehand. With a myriad of metrics, extensive integration potential, and reasonable accuracy, it’s more than enough for the average person to get into fitness tracking and improving their health.

Let me know if you have any thoughts on this device or any other suggestions for similar products worth checking out. Feel free to contact me here.

For context, this is my current setup to get my email into a Maildir directory and access it offline:

    ┌──────────────┐        
    │ IMAP Server  │        
    │ (e.g. Gmail) │        
    └──────┬───────┘        
           │                
         mbsync             
        Push/Pull           
           │                
           ▼                
    ┌──────────────┐        
    │ Local Machine│        
    │   Maildir    │        
    └──────┬───────┘        
           │                
       notmuch new          
           │                
           ▼                
    ┌──────────────┐        
    │   Indexed    │        
    └──────────────┘        
                            
Accessible with any frontend
                            
  e.g. - Emacs              
       - *notmuch.nvim*
       - neomutt            

The mbsync and notmuch stack is pretty canonical at this point and most setups use the same. It works fine on its own but requires frequent polling and it’s still not as fresh as I would like.

Note: Check out my Neovim plugin notmuch.nvim, which acts as a frontend for reading and writing email inside your favorite text editor :-).

IMAP IDLE command

As per RFC 2177, IMAP servers have a useful capability called IDLE. The IDLE command allows clients to receive “push notifications” from the server upon an update (new/updated/removed mail) from a watched mailbox.

With a specialized tool (see below for goimapnotify), you can setup hooks that pull/synchronize your Maildir with the server whenever a new message arrives in that mailbox.

To check whether your mail server supports this capability, run the following:

# Replace "imap.example.com:993" with your provider's IMAP details
openssl s_client -connect imap.example.com:993 -crlf -quiet
* OK IMAP server ready

# Type this once you are connected
a1 CAPABILITY

* CAPABILITY IMAP4rev1 IDLE NAMESPACE UIDPLUS MOVE AUTH=PLAIN

For more information on IDLE and how it works, check out the RFC reference.

goimapnotify

goimapnotify is a Go utility (improved version of the older imapnotify) that executes scripts on IMAP mailbox changes (new/deleted/updated messages) using the IDLE command on capable servers.

It’s configured with a YAML file that allows for control over multiple accounts, and configurable per-mailbox behavior.

Installation

It’s a Go program so you can use go install to install it:

go install gitlab.com/shackra/goimapnotify/cmd/goimapnotify@latest

Configuration

Here’s my sample configuration that allows me to get notifications on new/updated/removed mail (no sensitive information):

# ~/.config/imapnotify/gmail.yaml

configurations:
  -
    host: imap.gmail.com
    port: 993
    tls: true
    tlsOptions:
      rejectUnauthorized: true
      starttls: false
    idleLogoutTimeout: 15
    username: '<YOUR-EMAIL>'
    # password: '<YOUR-PASSWORD>'
    passwordCMD: '<COMMAND-TO-PASSWORD-MANAGER>'
    xoAuth2: false
    boxes:
      -
        mailbox: INBOX
        onNewMail: 'mbsync gmail:INBOX'
        onChangedMail: 'mbsync gmail:INBOX'
        onNewMailPost: 'notmuch new'
        onChangedMailPost: 'notmuch new'

The boxes section defines the behavior. onNewMail and onChangedMail trigger mbsync <account>:INBOX to start synchronizing to my Maildir. onNewMailPost and onChangedMailPost run notmuch new to index any updates in notmuch where the tagging and searching capabilities work.

Persistent systemd service

You could run the goimapnotify program with this configuration manually:

goimapnotify -conf ~/.config/imapnotify/gmail.yaml

But you would be better served by defining a small systemd service for this so that it runs in the background automatically:

; ~/.config/systemd/user/goimapnotify.service

[Unit]
Description=IMAP IDLE Notifier
Documentation=https://gitlab.com/shackra/goimapnotify

[Service]
Type=simple
; Replace this path with `command -v goimapnotify`
ExecStart=/home/yha/go/bin/goimapnotify -conf %h/.config/imapnotify/gmail.yaml
Restart=on-failure
RestartSec=5

[Install]
WantedBy=default.target

Don’t forget to reload your systemd config and enable and start the service:

systemctl --user daemon-reload
systemctl --user enable --now goimapnotify.service

Conclusion

Now, whenever I receive new emails, I am not beholden to whenever my whim compels me to refresh and update my sync flow. I can safely rely on goimapnotify to receive those update notifications from Gmail and accordingly run mbsync and notmuch to sync my Maildir, which is particularly useful when I need to reach for an email OTP or a confirmation email quickly.

For any thoughts or suggestions, feel free to contact me.

One of the main reasons I gravitated towards the Fitbit Air was that, with the Google Health App, my health metrics are synchronized to my Google account, which in turn can be pulled offline over API (data ownership!).

This means that I can fetch and synchronize all my health data offline and visualize it to do my own collection and wrangling with the data.

This is what I built vitald to do: it is a systemd-compatible service that periodically pulls my health data, stores it into a database, and connects it to Grafana for visualization and playing around with the data to make better health choices.

Showcase

It’s critical to note that wearable fitness trackers provide estimates of health metrics and should not be seen as 100% accurate data. Do not use commercial wearables as replacements for medical professionals.

The end result from this project is that I created 6 analytics views for Grafana. Below is the primary “overview” dashboard that I use to see my metrics at a glance.

This overview dashboard contains:

• Daily steps count
• A plot of my recorded weight over time
• My resting heart rate (RHR) over time
• Heart rate variability over time
• Sleep duration every day
• Exercise data including total and active zone minutes
• Daily calories in and out

This contains the high-level data I would like to know in a quick skim. Then there are other dashboards and queries for data points I may find interesting to track to answer questions such as:

• How does my calorie surplus/deficit affect my weight over time? What’s my BMR?
• How does strenuous exercise affect my sleep duration?
• Is there any correlation between my sleep duration and weight?
• How did last year’s work stress affect my HRV and well-being?

This kind of information is not so trivially analyzed with the basic Google Health app, and definitely not available under Apple’s ecosystem since you don’t own your data there.

Architecture and data flow

Below is the architecture diagram for the project’s data flow. The first two are straight forward and already provided by the hardware and Google’s infrastructure.

The vitald CLI and the components hosted locally on my homelab are managed by this project.

The subsequent sections describe these 2 components in more detail.

Go utility

At its core, vitald is a Go command-line tool. It handles the OAuth management with Google Cloud, and is responsible for fetching, storing, and normalizing the data sets from the Health API into JSON archives, as well as structured data in Postgres.

In a nutshell (note it is recommended to use docker/podman):

# First time authentication (sign-in and accept)
docker compose run --rm --no-deps --service-ports vitald auth

# Verify identity with Cloud project
docker compose run --rm --no-deps vitald identity

# Check on the status and last run(s) if any
docker compose run --rm --no-deps vitald status

# Initiate the first sync command
docker compose run --rm --no-deps vitald sync

# Health check
docker compose run --rm --no-deps vitald doctor
docker compose run --rm --no-deps vitald doctor --online # Check your auth

Compose and systemd

The project stack (Postgres, Grafana, vitald binary) are bundled in compose.yaml, including backup and restore services as well.

If you just want to run it once to try it out:

# Set up the project containers
docker compose up -d

# Then, for vitald, run the commands listed earlier

The scripts/install-systemd.sh script installs 4 service unit/timer pairs for automated management, ideal for long-term usage and homelab setups. Under the hood it uses the same compose commands.

After running this script you can verify the installed timers, as well as their previous and next scheduled runs:

systemctl --user list-timers "vitald-*"

Sample output:

NEXT                            LEFT LAST                              PASSED UNIT                       ACTIVATES
Wed 2026-08-19 18:16:51 +03 1h 29min Wed 2026-08-19 12:16:52 +03 4h 30min ago vitald-sync.timer          vitald-sync.service
Thu 2026-08-20 02:01:53 +03       9h Wed 2026-08-19 02:01:56 +03      14h ago vitald-doctor.timer        vitald-doctor.service
Thu 2026-08-20 03:06:57 +03      10h Wed 2026-08-19 03:06:58 +03      13h ago vitald-backup.timer        vitald-backup.service
Sun 2026-08-23 04:01:53 +03   3 days Tue 2026-08-18 12:55:04 +03            - vitald-verify-backup.timer vitald-verify-backup.service

Steps to run it yourself

1. Clone repo

git clone git@github.com:yousefakbar/vitald.git
cd vitald

2. Copy .env.example to .env

3. Populate required variables in .env

   • From Google Cloud Dashboard
     • GOOGLE_CLIENT_ID
     • GOOGLE_CLIENT_SECRET
   • Generate using openssl rand -hex 32
     • POSTGRES_PASSWORD (and update DATABASE_URL)
     • GRAFANA_ADMIN_PASSWORD
     • GRAFANA_SECRET_KEY
     • VITALD_GRAFANA_DB_PASSWORD
   • Generate using openssl rand -base64 32
     • .restic-password file
   • Specify the container engine in $VITALD_CONTAINER_ENGINE
     • Defaults to podman
     • You can switch it to docker
   • Specify tailscale IP in $GRAFANA_ROOT_URL to access externally

4. Source the .env variable to export their variables to your environment

set -a
source .env
set +a

5. Run docker compose up -d for image pulling and first time setup

6. Initial vitald run for auth and identity management

docker compose run --rm --no-deps --service-ports vitald auth
docker compose run --rm --no-deps vitald identity

7. Bring down compose project and then install the systemd units

docker compose down # (optional)
# "--engine docker" depends on if you use docker or podman (default)
./scripts/install-systemd.sh --engine docker

Google Cloud pre-requisites

Make sure you create a Google Cloud project from their dashboard and get a Client_ID and Client_Secret to use in the .env file.

Even more important is to make sure that it has the needed API permissions:

• googlehealth.activity_and_fitness.readonly
• googlehealth.health_metrics_and_measurements.readonly
• googlehealth.sleep.readonly
• googlehealth.nutrition.readonly

The auth and fetching will not work if you don’t have these permissions on the client generated.

Conclusion

In this day and age, data is your most valuable asset, so strive to own your data as much as possible.

By having access to your raw data, you can now take more intentional and informed decisions related to your health.

Just make sure not to obsess over it and remember to enjoy the moment!

With that said, although this is a personal project I made, I’d love to hear your thoughts and feedback. Anything related to either the technical implementation or, on a more creative side, the potential use cases for these dashboards are more than welcome.

Feel free to reach out

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.

“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!

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

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

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

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.

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.