DEV Community: Benjamin Koimett

Master the Python Piscine: Your Ultimate OOP, Data, and Automation Cheat Sheet 🐍🚀

Benjamin Koimett — Mon, 20 Jul 2026 08:55:28 +0000

Surviving a Python Piscine (or an intensive dev boot camp) is all about speed, retention, and having a reliable fallback when your brain stalls at 3 AM. Whether you are dealing with rigid auto-graders or rushing to meet a midnight deadline, you need code that works—fast.

This guide acts as your ultimate, SEO-optimized reference blueprint. Bookmark this page, keep it open in a side tab, and use these production-ready patterns to ace every module from basic logic to Object-Oriented Programming (OOP) and API development!

1. Python basics & control flow

The foundation of any piscine relies on syntax precision, clean loops, and deterministic conditional paths.

# Variables, dynamic typing, and structural formatting
user_name = "Developer"
bootcamp_days = 28
intensity_ratio = 4.5  # Float

# f-strings provide clean, optimized string interpolation
print(f"Candidate {user_name} is grinding for {bootcamp_days} days straight!")

# Control flow: Check structural logic sequentially
score = 85
if score >= 90:
    grade = "Level 8 Expert"
elif score >= 75:
    grade = "Level 5 Proficient"
else:
    grade = "Needs Review"

2. Advanced flow & data handling

When standard loops are too slow or verbose, modern Python leverages comprehension patterns and robust structures to process complex streams cleanly.

# Comprehensions: Transform lists inline with filtering logic
raw_scores = [45, 72, 88, 91, 103, -5]
validated_scores = [x for x in raw_scores if 0 <= x <= 100]

# High-performance collections: Dictionaries and Sets
# Sets automatically enforce uniqueness and optimize lookups
unique_tags = {"oop", "apis", "oop", "numpy"}  # Results in {'oop', 'apis', 'numpy'}

# Dictionary manipulation via iteration
topic_completion = {"basics": True, "pandas": False, "apis": False}
pending_topics = {k: v for k, v in topic_completion.items() if not v}

3. Strings & file I/O operations

Interfacing with external files safely requires proper context management to ensure your operating system resources are released instantly, preventing memory leaks during testing.

# File handling: Always use the 'with' context manager
file_path = "piscine_notes.txt"

# Writing structured lines safely
with open(file_path, "w", encoding="utf-8") as file:
    file.write("Day 14: Data structures mastered.\nDay 15: Starting NumPy.")

# Reading file contents safely line-by-line
with open(file_path, "r", encoding="utf-8") as file:
    for line in file:
        clean_line = line.strip()  # Strips trailing whitespace/newlines
        print(f"Processed: {clean_line}")

4. High-performance data: NumPy & Pandas

Data analysis and mathematical operations at scale require native vectorization. Standard Python loops fail under load; vectorization via NumPy and Pandas pushes computations directly to C-level speeds.

import numpy as np
import pandas as pd

# NumPy: Fast multi-dimensional vector math
matrix = np.array([[1, 2], [3, 4]])
doubled_matrix = matrix * 2  # Vectorized operation across all elements

# Pandas: Structured DataFrames for analytical processing
data = {
    "Candidate": ["Alice", "Bob", "Charlie"],
    "XP":,
    "Submissions": [14, 9, 3]
}
df = pd.DataFrame(data)

# Filtering data rapidly without structural loops
top_performers = df[df["XP"] > 1000]
print(top_performers)

5. Web architecture: APIs & JSON parsing

Interfacing with remote servers requires standard protocols. We query REST endpoints using HTTP verbs and serialize raw responses directly into standard data shapes.

import json
import requests

# Querying an external REST endpoint safely
url = "https://github.com"
try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()  # Throws an HTTPError if the response code is bad

    # JSON Deserialization: Transforming string payload to a native dictionary
    user_data = response.json()
    print(f"GitHub Username: {user_data.get('login')}")

except requests.exceptions.RequestException as error:
    print(f"Network transaction failed: {error}")

6. Object-Oriented Programming (OOP)

OOP helps scale systems cleanly. Instead of loose scripts, encapsulate internal variables, protect structural states, and use modular inheritance lines to extend code easily.

from abc import ABC, abstractmethod

# Abstract base class: Establishes a strict contract for subclasses
class Exercise(ABC):
    @abstractmethod
    def evaluate(self):
        pass

# Inheritance & Encapsulation
class PythonExercise(Exercise):
    def __init__(self, name, level):
        self.name = name          # Public attribute
        self.__level = level      # Private attribute (Name mangling applied)

    # Property decorator: Controlled reader access to private data
    @property
    def level(self):
        return self.__level

    # Concrete implementation of abstract contract
    def evaluate(self):
        return f"Evaluating {self.name} at Level {self.__level}..."

    # Magic/Dunder Method: Structural representation string
    def __str__(self):
        return f"Exercise: {self.name} (Lvl {self.__level})"

# Usage demonstration
project = PythonExercise("OOP Basics", 8)
print(project)           # Triggers __str__
print(project.evaluate()) # Triggers interface contract

Summary sheet cheat index

Module Category	Core Tools & Keywords	Best Practice Tip
Control flow	`if`, `elif`, `else`, `f-strings`	Keep condition statements short and early.
Advanced handling	`list comprehensions`, `sets`	Use sets for instant operations on unique entries.
String & Files	`with open()`, `.strip()`	Never open files manually without context managers.
Data stack	`np.array`, `pd.DataFrame`	Avoid iterating rows; apply calculations globally.
APIs	`requests.get()`, `.json()`	Wrap requests in try-except blocks to catch drops.
OOP system	`class`, `self`, `@property`, `abc`	Use properties over raw getters to keep access clean.

The No-Nonsense Guide to Protecting Your Brainchild in Kenya 🇰🇪 (For Innovators, Programmers & Creatives)

Benjamin Koimett — Wed, 15 Jul 2026 12:59:02 +0000

So, you have a killer app idea, or you have just written a song that is going to blow up, or maybe you have built a gadget that solves a real problem. That is awesome. You are part of Kenya’s innovation engine, and the world needs to see what you have got.

But here is a scary thought: what happens if someone else takes your idea? What if a bigger company sees your app and clones it, or a stranger starts selling your artwork online?

Intellectual Property (IP) is the legal armor that protects your creations. For a long time, people thought it was just for big corporations with suitcases full of cash, but that is not true anymore. This guide is a simple, practical look at how to protect your work here in Kenya .

I want to demystify the "legalese" and give you a roadmap. We will look at the types of protection, the institutions that help you, and the step-by-step instructions to get you started.

Ready? Let’s go.

What is Intellectual Property (IP) and Why Should You Care? 🤔

Think of Intellectual Property as your brain’s "signature" on your work. It gives you a bundle of rights to control how your creation is used. If you have built something valuable, you should own the right to profit from it .

For example, your friend might think your business name is cool, but if they start using it, that is technically "passing off" your brand. Registering your IP gives you a legal weapon to stop them .

The Main Types of IP in Kenya

In Kenya, there are three main pillars of IP law that protect different types of creations .

Patents & Utility Models: For the Inventors and Gadget Makers 🔧

If you have invented a new machine, a manufacturing process, or a technical solution, this is for you .

· Patents: This is the big one. It protects inventions that are new, involve an inventive step (not obvious), and have industrial applicability (it works!). Patents last for 20 years .
· Utility Models (Petty Patents): This is for smaller, incremental innovations that might not be "non-obvious" enough for a full patent. They are usually quicker and cheaper to get and last for 10 years .

Trademarks: For the Brand Builders

This protects your brand identity, which is everything that tells the world who you are: your business name, your logo, a specific slogan, or even the shape of your product .

· The Golden Rule: Registering your business name on eCitizen does NOT give you trademark protection. That is just a business name. To protect your brand, you must file with KIPI .
· Duration: Protection lasts for 10 years and can be renewed forever .

Copyright protects the expression of an idea, not the idea itself. This is your world if you write code, design graphics, create music, produce videos, or write books .

· The Important One for You: In Kenya, software source code is protected as a "literary work" under copyright law. You cannot patent software in Kenya just for being software, so this is how you protect your app or platform .
· Automatic Protection: Good news! Copyright protection is automatic the moment you create your work in a tangible form (like saving it on your laptop).
· The "Extra Layer": While automatic, you can register it with KECOBO for solid evidence in court .
· Duration: Usually, the author's life plus 50 years .

Trade Secrets: For the Proprietary Algorithms

Got a secret sauce? Maybe a unique algorithm or a customer database? This is a trade secret. Kenya does not have a specific "Trade Secrets Act," so protection relies on contracts and Non-Disclosure Agreements (NDAs) .

· Best Practice: Before you share your secret code or idea with a potential investor or developer, get them to sign an NDA first .

Who are the "IP Guardians" in Kenya?

You need to know the right government offices to deal with .

· KIPI (Kenya Industrial Property Institute): The big boss for Patents, Utility Models, and Trademarks.
· KECOBO (Kenya Copyright Board): The guardians of Copyright.

Your Step-by-Step Guide to Getting Protected (Simplified) 📝

Here are the simplified processes for securing your work.

I. How to Register a Patent or Utility Model (The KIPI Way)

If you have a tangible invention, here is the path to follow .

Do a Search First: Before you spend money, check the KIPI database to make sure no one else has already patented your idea. You might want a professional to do a global search .
Decide on Your Application Type: · Provisional Application: This is a "placeholder." It gives you 12 months to perfect your invention and file the complete application, securing your filing date. Super helpful if you want to "test the market" first . · Complete Application: This is the full, detailed application ready for examination .
Prepare Your Documents: Your application must include : · A Request Form (IP 3) with all your details. · A Description of the invention that is detailed enough for an expert to understand. · Claims that define the exact scope of protection you want. · An Abstract summarizing your invention. · Drawings (if necessary).
Submit to KIPI: File your application and pay the fees. If you are outside Kenya, you need a local agent .
The Examination Process: · Formal Examination: KIPI checks if your paperwork is complete . · Publication: Your application is published in the Kenya Industrial Property Journal . · Substantive Examination: KIPI checks if your invention is truly novel. This can take 24-36 months .
Grant: If you pass, congratulations! You get your certificate and your patent is valid for 20 years (or 10 for utility models), but you have to pay annual maintenance fees .

II. How to Register a Trademark (Your Brand Armor)

Protect your business identity with a trademark .

Conduct a Search: Head to KIPI's database to see if your chosen name or logo is available .
Submit Your Application: File an application specifying your brand details and the classes of goods or services it covers .
Examination: KIPI will examine your application to ensure it is distinctive and doesn't conflict with others .
Publication: Your trademark will be published in the IP Journal for 60 days. If nobody objects to it (opposes it), you are in the clear .
Certificate: You will be issued a certificate, and your trademark is protected for 10 years, renewable forever .

III. How to Register Copyright (For Your Creative Works)

Protecting your code or your music is simpler and mostly free .

Create Account: Go to the National Rights Registry (NRR) portal on the KECOBO website and create an account .
Submit Your Work: Upload your work (e.g., your software code, music file, novel) .
Pay Fees (or not): Good news! KECOBO is currently offering free copyright registration! The Board has announced that fees will be introduced soon, so take advantage of the free period .
Get Your Certificate: Once processed, you get a certificate. You do not need it, but it is your "golden ticket" if you ever end up in court .

IV. Protecting Trade Secrets (The NDA Strategy)

No special application for this one. You need to build a fortress around your confidential info.

Draft an NDA: Get a solid Non-Disclosure Agreement from a lawyer, or find a free template you can adapt.
Use It: Make sure employees, freelancers, and even potential investors sign it before discussing your sensitive work .

Quick Summary Table 📊

Type of IP Protects... Who Handles It? How Long?
Patent Inventions KIPI 20 years
Utility Model Small improvements/ "Petty patents" KIPI 10 years
Trademark Brand name, logo KIPI 10 years (renewable)
Copyright Code, music, art, writing KECOBO Life + 50 years

A Final Word for the Programmers & Creatives

If you take away only one thing from this, let it be this: register your copyright with KECOBO while it is free, and do not share your source code without an NDA.

Your brainchild is your future. Protect it.

Need Help from the Pros? 🏛️

If this all feels a bit overwhelming, or if you are facing a complex legal challenge (like someone infringing on your patent), it is always wise to consult an advocate. I would recommend reaching out to a firm that specializes in IP and tech law like Njeri Koimett & Co Advocates [+254 740 710471]. They can handle the heavy lifting for you .

References & Further Reading 📚

This guide was built on information from KECtil lessons, Kenya's IP institutions and legal framework. For the official deep dive, check out the Kenya Industrial Property Institute (KIPI) at kipi.go.ke for patents and trademarks, and the Kenya Copyright Board (KECOBO) at copyright.go.ke for creative works and software protection . The legal foundation comes from the Industrial Property Act No. 3 of 2001, the Trade Marks Act Cap 506, and the Copyright Act No. 12 of 2001 . For case law that shows how IP rights play out in Kenyan courts, the Kenya Law website at kenyalaw.org is your friend—cases like Sanitam Services v. Rentokil [2006] KECA 362 (KLR) illustrate the importance of proper registration . If you want a thorough academic breakdown, the monograph Kenya Intellectual Property Law by Rutenberg, Ouma, and Munyi (2019) is an excellent resource .

Hashtags:

Kenya #IntellectualProperty #KenyanTech #CopyrightKenya #KECOBO #KIPI #PatentKenya #TrademarkKenya #StartupKenya #CreativesKE #SoftwareDeveloper #KenyanInnovation #ProtectYourWork #NairobiTech #FoundersKE #KECtil

Navigating Intellectual Property in Kenya

Benjamin Koimett — Tue, 14 Jul 2026 16:45:00 +0000

Kenyan Devs, Stop Assuming Your Code is Protected: A No-Jargon Guide to IP Law

As software engineers and tech founders building in hubs across Kenya, we pour months of late nights into writing clean code, building scalable architectures, and deploying features. But when it comes to safeguarding that work, there is a dangerous amount of misinformation floating around the ecosystem.
Many founders assume that registering a company on eCitizen protects their brand name, or that they need an expensive patent to secure their application's core engine.

Let's clear the confusion and lay down the exact legal framework for protecting tech innovations under Kenyan law.

1. The Ultimate Truth: Software is Copyright, Not a Patent

In Kenya, software code (per se) cannot be patented under the Industrial Property Act. Unless your code directly drives a novel hardware invention (like a specialized medical device or an IoT system), your codebase is legally treated as a literary work.

The Governing Body: Kenya Copyright Board (KECOBO).
How it Works: Your copyright protection exists automatically the moment you write the code. However, automatic isn't enough when dealing with courts or investors.
The Action Item: You should actively register your platform's repository with KECOBO via the National Rights Registry (NRR) portal on eCitizen. Having that official certificate provides prima facie evidence in a legal dispute, instantly proving you own the code as of a specific date.

2. Company Registration vs. Trademarking

This is the most common trap for Kenyan startup founders. You go to the eCitizen Business Registration Service (BRS), clear your name search, pay your registration fees, and launch your SaaS platform. You think your brand is safe. It is not.
Registering a company name only prevents another person from incorporating a business with that exact corporate name. It does not stop a competitor from launching an app using your app's name, logo, or slogan.

The Governing Body: Kenya Industrial Property Institute (KIPI).
The Process: To own your brand, you must file a trademark under the Trade Marks Act (Cap 506).
The Workflow:
Pay for an official TM27 Preliminary Search (KSh 2,000) to ensure no one else owns a similar mark.
1. File a TM2 Application to register your logo and name.
2. Your mark goes into the monthly KIPI Journal for a strict 60-day public opposition window. If no one objects, your trademark is approved for 10 years, renewable indefinitely.

3. The Big Legal Void: Trade Secrets & Algorithms

What happens to your proprietary machine learning models, database structures, or backend algorithms? Since they aren't easily patented, and copyright only protects the literal text of the code (not the underlying business logic), they fall under Trade Secrets.

The Kenyan Context: Kenya has no standalone Trade Secrets Act.
Your Shield: You must rely strictly on the Law of Contract.
The Action Item: Never show your core system architecture, unreleased APIs, or beta algorithms to prospective partners, contractors, or early hires without a signed, robust Non-Disclosure Agreement (NDA). Your employment contracts must explicitly state that all IP created on company time belongs solely to the company.

4. The Quick Reference Guide for Devs

Asset	What Protects It	Local Agency	Timeline Note
Source Code & UX copy	Copyright	KECOBO	Author’s life + 50 years
App Name, Slogans, Logos	Trademark	KIPI	60-day open opposition phase before grant
Hardware Innovations / IoT	Patents / Utility Models	KIPI	12-month window to expand globally via Paris Convention
Backend Algorithms & Logic	Trade Secrets	Contracts / NDAs	Dependent on your internal security & legal agreements

The Bottom Line for Founders

A secure local IP foundation safeguards your market share and signals seriousness to venture capital firms and regional partners.
Before you launch your next marketing campaign, spend the time to run a trademark search, secure your NRR copyright certificate on eCitizen, and tighten your team’s NDAs. The cost of a proactive legal defense is always a fraction of the cost of losing your brand identity or code to a competitor.
Have you ever navigated KIPI or KECOBO for your tech projects? Let's discuss your experiences and challenges in the comments below!

Day 1 at the Kisumu Lightning Bootcamp: I Actually Got Bitcoin Running (And So Can You)

Benjamin Koimett — Tue, 09 Jun 2026 05:56:27 +0000

Okay so I showed up at Zone01 Kisumu this morning not really knowing what to expect. The email said 9 AM and I got there at like 8:45 because I was lowkey nervous.

First thing - free lunch is real. They mentioned it in the email but I wasn't sure if it was one of those "technically yes but good luck" situations. But yeah lunch happened.

Anyway the main thing we did today was setting up Bitcoin Core in regtest mode. I thought this was gonna be a nightmare because last time I tried installing anything blockchain related on my laptop it took me like 3 hours and I almost threw the whole machine out the window.

But honestly? It was smooth.

Here's what we did:

Step 1 - Make the directory

mkdir ~/.bitcoin

That's it. Hidden folder. Done.

Step 2 - Create the config file
I used VS Code because vim scares me outside of quick edits.

code ~/.bitcoin/bitcoin.conf

Step 3 - Paste the config settings
Just copied what the instructor put on the screen. regtest=1, server=1, daemon=1, plus a rpcuser and rpcpassword. Nothing complicated.

Step 4 - Start Bitcoin Core

bitcoind -regtest

And... nothing happens. That's actually correct lol. It runs in the background. I kept staring at my terminal like "did it crash?" but nope. That's just how daemon mode works.

Step 5 - Check if it's alive

bitcoin-cli -regtest --rpcwait getblockchaininfo

Got back a huge JSON response with "blocks": 0 and all that. Felt like a hacker even though I just copy pasted.

Then we did the exercises. Created two wallets (alice and bob because why not keep it simple). Generated addresses for both. Mined 101 blocks to alice's address and suddenly she had 50 BTC. Well, regtest BTC. But still.

I tried to send 10 BTC to bob and typed -regtst instead of -regtest like an idiot. Got an error. Fixed it. Transaction went through.

The fun part was inspecting the raw transaction. I kept trying to pass the address to getrawtransaction and getting errors because obviously that's not how it works. You need the TXID. Once I figured that out (and stopped trying to pass "$ALICE" like a variable name is gonna work), I could see all the details. The vin, vout, witness data, everything.

We also generated different address types - legacy, bech32, bech32m. The bech32m addresses look wild. bcrt1pruhsp4g66cca... yeah that's a lot of characters.

By the end of the day I had:

A working regtest node
Two wallets with balances
Successfully sent transactions
Explored blocks and mempool
Generated 3 types of addresses

The whole setup from zero to mining blocks took maybe 20 minutes. Most of that was waiting for bitcoind to start the first time.

What I appreciated is that the instructors didn't just hand us commands to copy. They explained what each config setting does. regtest=1 means private test network. server=1 enables the RPC server so you can talk to Bitcoin Core from the command line. daemon=1 runs it in the background. Simple stuff but it makes sense now.

One thing I messed up - I had a typo on a blockhash when trying to inspect a block. Left a quote mark open or something. The error message was actually helpful for once. "blockhash must be of length 64" - okay fair enough.

The WhatsApp group is active. People were posting their errors and getting answers within minutes. The "killall bitcoind" command saved at least three people who somehow started multiple instances.

Tomorrow we're doing more. I think we get into the Lightning Network setup. But for day 1? I'm calling it a win. My laptop didn't catch fire. I didn't get stuck on config hell. And I actually understand what regtest mode is for now.

If you're doing this bootcamp and haven't set up yet - just follow the steps in order. Don't skip the config file. Use --rpcwait when you first check because bitcoind takes a second to wake up. And don't put quotes around your blockhash when you forget to close them like me.

That's it. Day 1 done. 4 more to go.

Posted from Kisumu after way too much chai

From Smart Contract Hell to JavaScript Solace: Building ArdhiChain for a 36-Hour Hackathon

Benjamin Koimett — Sun, 31 May 2026 10:53:14 +0000

---
title: "From Smart Contract Hell to JavaScript Solace: Building ArrdhiChain for a 36-Hour Hackathon"
published: true
description: "How I survived Polygon Amoy testnet failures, gas estimation nightmares, and a Friday 5 PM MVP deadline by finding peace in vanilla JavaScript and optimistic UI."
tags: [web3, hackathon, javascript, polygon, solidity, devjournal]
---

In the beginning...

Timeline: Thursday 8 AM to Friday 5 PM MVP deadline. Pitches started Friday 11 AM (yes, while I was still debugging).

Sanity level: Negative.

Outcome: Shipped. Barely.

This past Thursday to Friday wasn't a 72-hour marathon. It was a 36-hour sprint where the smart contracts tried to break me, the Polygon Amoy testnet played games, and JavaScript became my unexpected sanctuary.

Here's the raw, unfiltered story of building ArrdhiChain - a web3 dApp - under hackathon conditions that felt designed to cause panic attacks.

Thursday Morning: The Overconfidence Phase

The hackathon kicked off Thursday at 8 AM. MVP needed by Friday 5 PM. Pitches started Friday 11 AM (meaning the judges would be circulating while I was still patching bugs).

My idea: A decentralized app on Polygon Amoy testnet where users could interact with a custom smart contract. Simple. Elegant. Wrong.

Thursday 9 AM: Smart contracts written in Solidity. Compiled flawlessly. I felt invincible.

Thursday 10 AM: First deployment attempt. FAIL. Gas estimation errors. Network timeouts. MetaMask crying.

Thursday 11 AM: Discovered I was on Mumbai testnet, not Amoy. Two hours gone. Classic.

Lesson #1: The network dropdown is not your enemy. Ignoring it is.

Thursday 2 PM: Finally got the contract live on Amoy:

🔗 0xYOUR_CONTRACT_ADDRESS

I celebrated with cold coffee. Too soon.

Thursday Night: The Web3 Integration Nightmare

By Thursday evening, the contract was verified. But connecting it to the frontend was a special kind of torture:

Ethers.js v5 vs v6 conflicts - two hours of Stack Overflow archaeology
WalletConnect dropping sessions every third refresh
React state + async blockchain calls creating race conditions I didn't even know existed

Every transaction took 30 to 45 seconds. Users would see "Pending..." and close the tab. In a hackathon with judges walking the floor by Friday 11 AM, that's a death sentence.

Thursday midnight: I pushed broken code to GitHub and stared at my ceiling for an hour. The MVP deadline was 17 hours away.

Friday Morning: Panic, Then Solace

Friday 7 AM: Coffee IV drip engaged. Judges would arrive in 4 hours. The contract worked on the backend, but the frontend was unusable.

Then I made a decision that saved the project:

Stop fighting the blockchain. Fall in love with the frontend.

I stripped the complexity. Hard.

1. Built a Mock Provider Fallback

If MetaMask wasn't detected or the network was wrong, the UI gracefully fell back to a read-only mode. Users could still see contract data, explore features, and understand the app - even if they couldn't transact yet.

2. Optimistic UI with Local Cache

Even if a transaction took 30 seconds, the UI updated instantly. I stored pending transactions in localStorage, showed a "confirming..." badge, and synced with the blockchain in the background.

Users felt speed. That's the JavaScript superpower.

3. Transaction State Machine with useReducer

No more scattered isLoading flags across 12 components. One clean reducer:

switch (state.status) {
  case 'idle': // show form
  case 'pending': // show spinner + optimistic data
  case 'success': // show confirmation + clear cache
  case 'error': // show friendly retry button
}

4. Friday 10:30 AM - MVP Ready

Thirty minutes before judges started walking the floor. The contract was live. The UI was responsive. And users could actually use it without throwing their phones.

Friday 11 AM: Pitches began. I demoed ArrdhiChain with a smile. The backend was held together with duct tape and hope, but the frontend shipped.

What I Actually Shipped

✅ Smart contract live on Polygon Amoy Testnet

✅ Verified contract on Amoy Polygonscan

✅ React frontend with read-only fallback

✅ Optimistic UI + localStorage transaction cache

✅ "Solace Mode" toggle - disables writes, keeps UI butter-smooth

Live demo (Amoy): [https://land-ledge-git-frontend-benjie-bkoimetts-projects.vercel.app/dashboard]
Contract: 0xYourAddress

GitHub: [https://github.com/bkoimett/land-ledge.git]

From Smart Contract Hell to JavaScript Solace: Building ArrdhiChain for a 36-Hour Hackathon

The Hard Truth About Hackathon Web3

Building a dApp in 36 hours is not development. It's survival.

Smart contracts will compile but fail to deploy.
Testnets will lie about gas fees.
MetaMask will betray you at the worst moment.

But JavaScript? JavaScript is home.

When the blockchain is slow, the frontend can be fast.

When transactions fail, the UI can recover.

When judges are watching, a smooth demo beats a perfect contract.

Lesson #2: In a hackathon, the user experience is the product. The blockchain is just the backend.

What I'd Do Differently (And What I'm Keeping)

Next time:

Start with the frontend mock first, add web3 later
Use Wagmi or useDapp instead of raw ethers.js
Test the entire transaction flow before writing a single line of Solidity

What I'm keeping:

Optimistic UI always
LocalStorage as a transaction journal
The "Solace Mode" pattern - read-only fallbacks for every web3 app

Final Thoughts

The hackathon didn't end at Friday 5 PM. But by then, I had shipped. The judges saw a working product. Users saw a smooth interface. And I learned that web3 stress is real - but JavaScript is where peace lives.

If you're building a dApp under a deadline, remember:

await is a suggestion, not a guarantee
The frontend is where users live
A well-placed try/catch is sometimes more valuable than a perfect contract

And when the blockchain breaks your heart, JavaScript will still be there.

Have you ever survived a web3 hackathon? What saved you - better planning or a last-minute frontend miracle? Drop your war stories below.

web3 #hackathon #javascript #polygon #solidity #buildinpublic #devjournal

The AI-Ready Engineer: Why Nation.dev’s Visit to Zone01 Kisumu Changes the Game for African Tech

Benjamin Koimett — Sat, 16 May 2026 21:19:47 +0000

The global tech landscape is shifting at a breakneck pace. For a long time, the narrative around tech talent was centered on traditional silicon valleys. But today, the narrative is being rewritten right here in Kenya.

This week, we had the incredible honor of hosting Juan Carlos Mauritz, Co-Founder and CEO of Nation.dev, right here at Zone01 Kisumu. His visit wasn't just a casual meetup—it marked a massive milestone for software engineering talent in East Africa through a landmark partnership agreement signed between LakeHub and Nation.dev.

As an apprentice and software engineer embedded in the Zone01 ecosystem, this visit hit home. Here is my take on what this partnership means for us, and why the insights shared about the future of software engineering in the age of AI matter to developers everywhere.

Bridging the Gap: From Kisumu to the Global Market

The core mission of Zone01 Kisumu and LakeHub has always been clear: to identify, nurture, and accelerate world-class tech talent. However, talent without opportunity can stagnate.

This new partnership explicitly tackles that bottleneck. By aligning with Nation.dev, LakeHub is creating direct, friction-free pathways for local developers to access global roles, international industry exposure, and cutting-edge skills development.

As Dorcas Owinoh, Co-Executive Director at LakeHub, perfectly captured:

"Our partnership with Nation.dev ensures that our apprentices access global roles in software development. We are proud to join an impressive list of talent partners that Nation.dev is already working with."

For those of us working hard on the ground in Kisumu, this is a massive validation. It proves that the code we are writing and the systems we are building are up to par with global standards.

"The Future of the Software Engineer in the Age of AI"

Beyond the paperwork, Juan Carlos delivered a powerful tech talk that resonated deeply with everyone in the room: "The Future of the Software Engineer in the Age of AI."

With the rise of LLMs, automated code generation, and AI pair programmers, a lot of junior developers are anxious about the future. Will AI replace us? Are we learning obsolete skills?

Juan Carlos completely flipped the script on these fears. Instead of viewing AI as a threat, he framed it as the ultimate equalizer.

"Artificial Intelligence will lower the barrier to entry for software developers as well as make them more efficient. This means that software developers will concentrate on their primary job of connecting dots and solving problems."

The Evolving Toolkit of a Modern Developer

This perspective shifts the definition of what it means to be a software engineer. If AI can write boilerplate code, scaffold APIs, and debug syntax errors in seconds, what is our value add?

The answer lies in high-level engineering. The software engineers who thrive in this new era will excel in:

Systems Thinking: Understanding how different services, databases, and architectures interact at scale.
Problem Definition: AI can give you answers, but humans still need to ask the right, deeply contextualized questions.
Creativity & Adaptability: Blending technical execution with unique user experience and business logic.

In short, AI is taking care of the routine syntax so that we can focus on building actual solutions. It turns us from code writers into problem solvers.

Building an AI-Ready Generation

The takeaway from this landmark engagement is clear: the future belongs to the AI-ready engineer.

Through the collaborative efforts of LakeHub, Zone01 Kisumu, and Nation.dev, we aren't just learning how to code; we are learning how to lead tech ecosystems. We are being equipped with future-proofed skills that ensure we don't just survive the AI wave—we ride it.

The tech ecosystem in Kisumu is fueled by community, grit, and an unshakeable drive to build great things. With global partners like Nation.dev entering the mix, the world is about to see exactly what African tech talent is capable of.

What are your thoughts on the evolving role of software engineers alongside AI? How is your local tech community adapting to these global shifts? Let's discuss in the comments below!

Partnerships #Zone01Kisumu #AI #NationDev #SoftwareEngineering #TechInAfrica

I built a crossword solver without React and survived to tell the tale 😅

Benjamin Koimett — Wed, 13 May 2026 08:17:35 +0000

For the past 3 years, my brain has been wired to:

npx create-vite@latest
useState, useEffect, useCallback
components inside components inside components

So when I decided to build a crossword puzzle solver the "vanilla way" — no framework, no JSX, no hot reload — I felt naked.

But here we are. With raw 2D arrays, nested loops, and the humbling realization that I still struggle with grid[r][c+len].

The Slots Extractor (I'm actually proud of this)

function extractSlots(grid) {
  const slots = [];
  for (let r = 0; r < grid.length; r++) {
    for (let c = 0; c < grid[0].length; c++) {
      if (grid[r][c] === '.') continue;

      // Across word?
      if (c === 0 || grid[r][c-1] === '.') {
        let len = 0;
        while (grid[r][c+len] && grid[r][c+len] !== '.') len++;
        if (len > 1) slots.push({row:r, col:c, len, dir:'across'});
      }

      // Down word?
      if (r === 0 || grid[r-1][c] === '.') {
        let len = 0;
        while (grid[r+len] && grid[r+len][c] !== '.') len++;
        if (len > 1) slots.push({row:r, col:c, len, dir:'down'});
      }
    }
  }
  return slots;
}

The Embarrassing Bug I Spent 2 Hours On

// My original canPlace function (BROKEN):
function canPlace(slot, word, grid) {
  for (let i = 0; i < slot.len; i++) {
    // ... check logic ...
    return true  // ← 💀 inside the loop! Only checked first letter!
  }
}

Yes. I really did that. Returned true after checking only the first character. My puzzle was accepting "abc" into a slot that needed "axc" because it saw the 'a' matched and dipped.

Shoutout to Phil Arturo 🙌

Phil, you kept telling me: "You need to understand the fundamentals, not just the frameworks."

I laughed then. I cry-laughed while debugging that return true at 11pm.

You were right. Vanilla JS humbles you. But it also teaches you how to think in loops, indices, and grid coordinates without a linter holding your hand.

The Fixed Version (Works Now, I Swear)

function canPlace(slot, word, grid) {
  const {row, col, len, dir} = slot;
  if (word.length !== len) return false;

  for (let i = 0; i < len; i++) {
    let r = row, c = col;
    if (dir === 'across') c = col + i;
    else r = row + i;

    const gridChar = grid[r][c];
    const wordChar = word[i];

    if (gridChar !== '.' && gridChar !== wordChar) {
      return false;  // Conflict!
    }
  }
  return true;  // ← OUTSIDE the loop, where it belongs
}

Final Takeaway

React is awesome. Vite is lightning fast. But once in a while, build something with just JavaScript, a terminal, and console.log debugging.

You'll feel stupid for 30 minutes. Then you'll feel like a god.

And you'll never put a return inside a loop again. 🤞

Thanks again Phil Arturo — this one's for you.

vanillajs #crossword #webdev #reactdev #fundamentals

I Left Go for JavaScript After 3 Months (Yes, I'm Insane)

Benjamin Koimett — Mon, 11 May 2026 08:00:25 +0000

I learned Go for three months. Made a few CLI tools, wrestled with pointers, felt smart.

Then I switched to JavaScript… a week ago. Yesterday I finally understood for loops and regex. Today I'm writing this article instead of crying.

Here's what the journey has been like so far. Spoiler: my brain hurts, but I'm laughing.

Day 1: "Wait, no types?!"

In Go, you write:

var age int = 25

In JavaScript, you write:

let age = 25;   // cool
age = "twenty five"; // still cool?!

I stared at my screen for 5 minutes. No compiler yelling? It felt like a teacher leaving the classroom. Pure chaos.

Then I tried "2" + 2 and got "22". Go would never. JavaScript is like that friend who says "yeah sure whatever" to everything.

Day 3: Loops… finally loops

I know loops from Go. for i := 0; i < 10; i++ – simple.

JavaScript has:

for
for...in
for...of
forEach
map

I asked my roommate which one to use. He said "depends". I said "depends on WHAT". He walked away.

I just use the normal for loop. It works. I'm happy.

Day 4: Regex (send help)

Go regex: re := regexp.MustCompile(\d+) – weird but fine.

JavaScript regex: /d+/ – wait, no quotes? And slashes? And why does test() exist but also exec() and match()?

I spent 20 minutes trying to get a simple email validator. My code worked. Then it didn't. Then it did again. I haven't slept since.

Joke break:

Why did the JavaScript developer go bankrupt?

Because he used == instead of === and his bank thought "0" meant zero dollars AND free money.

Day 5: The undefined abyss

In Go, variables have zero values (0, "", nil). Predictable.

In JS, there's undefined AND null.

I tried to print a variable I forgot to declare: undefined. No error. Just… nothingness.

Then I accidentally typed console.log(agee) instead of age. Still undefined. No crash. JavaScript just shrugged at me.

I miss Go's "agee not declared" slap on the wrist.

Day 6: Semicolons – to use or not to use?

Go forces semicolons behind the scenes. Fine.

JavaScript? You can skip them. But sometimes skipping breaks everything. Automatic Semicolon Insertion (ASI) sounds like a disease.

I now put semicolons everywhere. Even after if statements. Sue me.

Day 7: One week review

Thing	Go	JavaScript
Types	"You shall not pass"	"Eh, do whatever"
Loops	One kind, works fine	A zoo of options
Regex	`regexp.MustCompile`	`/slashy bois/`
Errors	`if err != nil` everywhere	`try { } catch(e) { }` then forget to catch
Fun level	7/10 (serious fun)	9/10 (chaotic fun)

Should you switch after 3 months of Go?

Only if you enjoy pain and laughter in equal measure.

I'm still terrible at JS. But every time something breaks in a hilarious way, I learn something new. Like yesterday: I learned that [] + [] is an empty string. WHY.

Anyway, back to studying regex. Pray for me.

P.S. If you know why [1,2] + [3,4] equals "1,23,4" – please comment. I need therapy.

Building Real-Time Collaboration: A Simple Guide to Operational Transformation in Go

Benjamin Koimett — Thu, 12 Mar 2026 06:26:33 +0000

Ever wondered how Google Docs or Figma allow multiple people to edit the same document at the same time without destroying each other's work?

The magic behind this is called Operational Transformation (OT) .

OT sounds like complex academic jargon (and it can be), but the core concept is beautiful in its simplicity. Today, we're going to demystify OT by building a tiny, working example in Go.

The Problem: The "Late Comer" Conflict

Imagine two users, Alice and Bob, editing the same text document: "Hello".

Alice decides to insert a space after "Hello". The document becomes "Hello ".
Bob, at the exact same time, decides to insert an exclamation mark at the end. The document becomes "Hello!".

If we just apply these changes in the order they arrive at the server, we have a problem. If the server applies Alice's change first, then Bob's, we get "Hello !" (which is fine). But if it applies Bob's first, then Alice's, we might get "Hello !" as well? Actually, let's look closer:

Server State: "Hello"
Bob's Action: Insert '!' at position 5.
Alice's Action: Insert ' ' at position 5.

If the server applies Bob's change first:

Server applies Bob's insert: "Hello!" (length 6, '!' at index 5).
Now it needs to apply Alice's insert (space at position 5). But position 5 is now occupied by Bob's '!'. The space gets inserted before the '!', resulting in "Hello !".

If the server applies Alice's change first, we get "Hello !" as well. So in this case, we are fine because the operations are commutative (order doesn't matter). But let's look at a case where it does matter.

The Real Conflict: Insert vs. Delete

Let's start with "Hello".

Alice highlights "ell" and deletes it. Desired result: "Ho". Her operation: Delete(start: 1, end: 4).
Bob decides to insert an 'X' at position 1 (between 'H' and 'e'). Desired result: "HXello". His operation: Insert(position: 1, char: 'X').

What happens if the server applies Bob's insert first?

Server: "Hello"
Apply Bob (Insert 'X' at 1): "HXello" (Indices: H=0, X=1, e=2, l=3, l=4, o=5)
Apply Alice (Delete from 1 to 4): We look at the current document. Delete from index 1 to 4. That means deleting indices 1, 2, 3, and 4. That's "Xell". The result is "Ho". This is correct! ("H" + "o").

Now, what if the server applies Alice's delete first?

Server: "Hello"
Apply Alice (Delete from 1 to 4): "Ho" (Indices: H=0, o=1)
Apply Bob (Insert 'X' at 1): Insert 'X' at position 1 of "Ho". This yields "HXo".

Uh oh! The final document is "HXo", but it should be "HXo"? Wait, let's check the desired result. If Bob wanted "HXello" and Alice wanted "Ho", the final result if they were truly collaborating would be "HXo". Actually, in this case, "HXo" is the correct, converged state!

So why do we need OT? Because in a real distributed system, the server might not be the one deciding the order. The clients need to be able to apply changes optimistically and then reconcile them. The key is that every client must end up with the same final state, regardless of the order they saw the operations.

OT solves this by transforming operations against each other so they can be applied in any order and still converge.

The Core Idea of OT

OT works by treating every edit as an operation (Op). When two operations happen concurrently, instead of just applying them in a raw order, we transform one operation against the other.

We need a function: transform(a, b) -> (a', b')

This function takes two operations that were applied to the same document state and returns two new operations. The guarantees are:

Inclusion Property: Applying a then b' results in the same document state as applying b then a'.
Context: a' is a adjusted to make sense after b has been applied, and vice-versa.

Building OT in Go

Let's implement a simplified text OT system in Go. We'll handle two operations: Insert and Delete.

1. Defining Our Operations

First, we define what an operation looks like.

package main

import "fmt"

// OpType defines the kind of operation
type OpType int

const (
    Insert OpType = iota
    Delete
)

// Operation represents a single change
type Operation struct {
    Type  OpType
    Pos   int // Position in the document (0-indexed)
    Data  string // The text to insert or delete
}

func (op Operation) String() string {
    if op.Type == Insert {
        return fmt.Sprintf("Insert('%s' at %d)", op.Data, op.Pos)
    }
    return fmt.Sprintf("Delete('%s' from %d)", op.Data, op.Pos)
}

2. Applying an Operation to a Document

We need a way to apply an operation to a string to see the result.

// Apply performs an operation on a given document state
func Apply(doc string, op Operation) string {
    switch op.Type {
    case Insert:
        return doc[:op.Pos] + op.Data + doc[op.Pos:]
    case Delete:
        return doc[:op.Pos] + doc[op.Pos+len(op.Data):]
    default:
        return doc
    }
}

3. The Heart of OT: The Transform Function

This is where the magic happens. We need to handle all combinations of operations (Insert vs Insert, Insert vs Delete, Delete vs Insert, Delete vs Delete). For simplicity, we'll assume deletions always delete the exact string present (so we store the Data in the delete op).

// Transform takes two operations that were applied to the same state
// and returns two operations that can be applied in reverse order
// to achieve the same final state.
func Transform(a, b Operation) (aPrime, bPrime Operation) {
    // Case 1: Both are Inserts
    if a.Type == Insert && b.Type == Insert {
        if a.Pos < b.Pos {
            // a happens before b in the document.
            // b's position needs to shift right by the length of a's insertion.
            aPrime = a
            bPrime = b
            bPrime.Pos += len(a.Data)
        } else if a.Pos > b.Pos {
            // b happens before a in the document.
            // a's position needs to shift right by the length of b's insertion.
            aPrime = a
            bPrime = b
            aPrime.Pos += len(b.Data)
        } else {
            // Same position. We need a rule. A common strategy is to use a tie-breaker
            // like UserID or in this case, we'll just say the second one (b) goes after.
            aPrime = a
            bPrime = b
            bPrime.Pos += len(a.Data)
        }
        return aPrime, bPrime
    }

    // Case 2: Both are Deletes
    if a.Type == Delete && b.Type == Delete {
        // This gets complex quickly with overlapping ranges.
        // For this simple example, we'll assume non-overlapping deletes for now.
        // A real implementation must handle overlapping ranges carefully.
        // Simplified: If a deletes something entirely before b's delete,
        // b's position needs to shift left by the length of a's deletion.
        if a.Pos+len(a.Data) <= b.Pos {
            aPrime = a
            bPrime = b
            bPrime.Pos -= len(a.Data)
        } else if b.Pos+len(b.Data) <= a.Pos {
            aPrime = a
            bPrime = b
            aPrime.Pos -= len(b.Data)
        } else {
            // Overlap! In a real system, you'd merge these.
            // We'll panic for this demo.
            panic("overlapping deletes not handled in this simple example")
        }
        return aPrime, bPrime
    }

    // Case 3: a is Insert, b is Delete
    if a.Type == Insert && b.Type == Delete {
        if a.Pos <= b.Pos {
            // Insert happens before the delete.
            // The delete's position needs to shift right.
            aPrime = a
            bPrime = b
            bPrime.Pos += len(a.Data)
        } else if a.Pos > b.Pos+len(b.Data) {
            // Insert happens after the deleted region.
            // The insert's position needs to shift left.
            aPrime = a
            bPrime = b
            aPrime.Pos -= len(b.Data)
        } else {
            // Insert happens inside the deleted region.
            // The insert is deleted! So aPrime becomes a no-op? Or we shift it.
            // In a real system, this is handled by the delete including the inserted text.
            // We'll simplify: move insert to the delete position.
            aPrime = a
            bPrime = b
            aPrime.Pos = b.Pos
        }
        return aPrime, bPrime
    }

    // Case 4: a is Delete, b is Insert (symmetrical to case 3)
    if a.Type == Delete && b.Type == Insert {
        // Transform (Delete, Insert) by swapping and using case 3, then swapping back.
        bPrimeSwapped, aPrimeSwapped := Transform(b, a)
        // aPrimeSwapped is the transformed Delete, bPrimeSwapped is the transformed Insert.
        return aPrimeSwapped, bPrimeSwapped
    }

    // Should never reach here if all cases covered
    panic("unknown operation combination")
}

Note: This Transform function is simplified for educational purposes. Production OT systems (like in ShareDB or Google Wave) handle hundreds of edge cases, especially around cursors, selections, and overlapping deletes.

Putting It All Together: A Test

Let's simulate a real concurrent edit scenario to see if our transformation works.

func main() {
    // Start state
    doc := "Hello"
    fmt.Printf("Start: '%s'\n", doc)

    // Two clients start from this state
    aliceOp := Operation{Type: Delete, Pos: 1, Data: "ell"} // Wants "Ho"
    bobOp := Operation{Type: Insert, Pos: 1, Data: "X"}     // Wants "HXello"

    fmt.Printf("Alice wants: %v\n", aliceOp)
    fmt.Printf("Bob wants: %v\n", bobOp)

    // Server receives Alice's op first, then Bob's (or vice versa).
    // To make them work concurrently, we transform them.

    aPrime, bPrime := Transform(aliceOp, bobOp)

    fmt.Printf("\nTransformed Alice: %v\n", aPrime)
    fmt.Printf("Transformed Bob: %v\n", bPrime)

    // Scenario 1: Apply Alice, then Transformed Bob
    state1 := Apply(doc, aliceOp)
    state1 = Apply(state1, bPrime)
    fmt.Printf("\nAlice first, then Bob': '%s'\n", state1)

    // Scenario 2: Apply Bob, then Transformed Alice
    state2 := Apply(doc, bobOp)
    state2 = Apply(state2, aPrime)
    fmt.Printf("Bob first, then Alice': '%s'\n", state2)

    // Check if they converge
    if state1 == state2 {
        fmt.Printf("\n✅ Convergence! Final state: '%s'\n", state1)
    } else {
        fmt.Printf("\n❌ Divergence! '%s' vs '%s'\n", state1, state2)
    }
}

Expected Output

When you run this, you should see:

Start: 'Hello'
Alice wants: Delete('ell' from 1)
Bob wants: Insert('X' at 1)

Transformed Alice: Delete('ell' from 2)
Transformed Bob: Insert('X' at 1)

Alice first, then Bob': 'HXo'
Bob first, then Alice': 'HXo'

✅ Convergence! Final state: 'HXo'

It works! We started with "Hello". The final document is "HXo". This makes sense: Alice deleted "ell" from "Hello" leaving "Ho", and Bob inserted an "X" right after the "H", resulting in "HXo".

By transforming Alice's operation from Delete at 1 to Delete at 2, we accounted for Bob's "X" being inserted before the deleted region.

What's Next?

This is just the tip of the iceberg. A real-world OT system needs:

Cursors & Selections: Transforming cursor positions so they don't jump around.
Undo/Redo: A robust stack system that works with transformed operations.
Networking: A way to send operations between clients and a server (WebSockets in Go are great for this).
Durability: Saving the operation log to a database.

If you're interested in exploring further, check out these excellent resources:

ShareDB: A real-time database backend based on OT.
The original OT paper by Ellis and Gibbs (1990).

OT is a fascinating field that bridges the gap between distributed systems and UX. Go's concurrency model and performance make it a fantastic language to build these real-time collaboration features.

Happy coding! 🚀

Building a Modern Portfolio with Tailwind CSS v4, React, and Vite

Benjamin Koimett — Wed, 18 Feb 2026 00:33:41 +0000

github : https://github.com/bkoimett/bkoimett-portofolio.git

Looking to build a sleek, modern portfolio that stands out? In this comprehensive guide, I'll walk you through creating a professional portfolio from scratch using the latest Tailwind CSS v4, React, and Vite. We'll build a fully responsive site with dark mode support and backend integration.

🚀 Why This Stack?

Vite: Lightning-fast build tool with instant hot module replacement
React: Component-based architecture for reusable UI elements
Tailwind CSS v4: Utility-first CSS with JIT compilation and dark mode support
React Router: Seamless client-side navigation
Axios: Promise-based HTTP client for API integration

📋 Prerequisites

Node.js (v18 or higher)
npm or yarn
Basic knowledge of React and Tailwind

🛠️ Step-by-Step Implementation

1. Project Initialization

# Create a new Vite project with React
npm create vite@latest my-portfolio -- --template react
cd my-portfolio

# Install dependencies
npm install tailwindcss @tailwindcss/vite @vitejs/plugin-react
npm install react-router-dom axios

# Start development server
npm run dev

2. Configure Vite for Tailwind v4

vite.config.js

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import tailwindcss from '@tailwindcss/vite'

export default defineConfig({
  plugins: [
    react(),
    tailwindcss(),
  ],
})

3. Set Up Global Styles

src/index.css

@import "tailwindcss";

/* Custom theme variables */
@theme {
  --font-sans: 'Inter', system-ui, -apple-system, sans-serif;
}

/* Dark mode support */
:root {
  color-scheme: light;
}

:root.dark {
  color-scheme: dark;
}

/* Smooth theme transitions */
* {
  transition-property: background-color, border-color, color, fill, stroke;
  transition-duration: 200ms;
  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');

4. Theme Context for Dark/Light Mode

src/context/ThemeContext.jsx

import React, { createContext, useState, useEffect, useContext } from 'react';

const ThemeContext = createContext();

export const useTheme = () => {
  const context = useContext(ThemeContext);
  if (!context) {
    throw new Error('useTheme must be used within a ThemeProvider');
  }
  return context;
};

export const ThemeProvider = ({ children }) => {
  const [isDark, setIsDark] = useState(() => {
    const savedTheme = localStorage.getItem('theme');
    if (!savedTheme) {
      return window.matchMedia('(prefers-color-scheme: dark)').matches;
    }
    return savedTheme === 'dark';
  });

  useEffect(() => {
    if (isDark) {
      document.documentElement.classList.add('dark');
      localStorage.setItem('theme', 'dark');
    } else {
      document.documentElement.classList.remove('dark');
      localStorage.setItem('theme', 'light');
    }
  }, [isDark]);

  const toggleTheme = () => setIsDark(!isDark);

  return (
    <ThemeContext.Provider value={{ isDark, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
};

5. Key Components

Theme Toggle Button - src/components/ThemeToggle.jsx

import React from 'react';
import { useTheme } from '../context/ThemeContext';

const ThemeToggle = () => {
  const { isDark, toggleTheme } = useTheme();

  return (
    <button
      onClick={toggleTheme}
      className="fixed top-6 right-6 p-3 rounded-full bg-gray-100 dark:bg-gray-800 hover:bg-gray-200 dark:hover:bg-gray-700 transition-colors z-50 shadow-md"
      aria-label="Toggle theme"
    >
      {isDark ? (
        <svg className="w-5 h-5 text-yellow-500" fill="currentColor" viewBox="0 0 20 20">
          <path fillRule="evenodd" d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z" clipRule="evenodd" />
        </svg>
      ) : (
        <svg className="w-5 h-5 text-gray-700" fill="currentColor" viewBox="0 0 20 20">
          <path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" />
        </svg>
      )}
    </button>
  );
};

export default ThemeToggle;

6. Building the Main Pages

Home Page - src/pages/Home.jsx

import React from 'react';

const Home = () => {
  return (
    <div className="min-h-screen flex items-center justify-center bg-white dark:bg-gray-900">
      <div className="max-w-3xl mx-auto px-6 text-center">
        <h1 className="text-5xl md:text-6xl font-light text-gray-900 dark:text-white mb-6 tracking-tight">
          Alex Chen
        </h1>
        <p className="text-xl text-gray-600 dark:text-gray-400 mb-8 max-w-2xl mx-auto">
          Software Engineer specializing in Cloud Infrastructure, DevOps, 
          and Embedded Systems
        </p>

        <div className="flex flex-wrap justify-center gap-3 mb-12">
          {['☁️ AWS', '🚀 Kubernetes', '💻 React', '🔧 Embedded C', '📦 Terraform', '🤖 CI/CD'].map((skill) => (
            <span
              key={skill}
              className="px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 rounded-full text-sm font-medium"
            >
              {skill}
            </span>
          ))}
        </div>

        <div className="flex justify-center space-x-4">
          <a 
            href="/projects" 
            className="px-6 py-3 bg-gray-900 dark:bg-white text-white dark:text-gray-900 rounded-lg hover:bg-gray-800 dark:hover:bg-gray-100 transition-colors font-medium"
          >
            View My Work
          </a>
          <a 
            href="/about" 
            className="px-6 py-3 border border-gray-300 dark:border-gray-700 text-gray-700 dark:text-gray-300 rounded-lg hover:border-gray-900 dark:hover:border-white hover:text-gray-900 dark:hover:text-white transition-colors font-medium"
          >
            About Me
          </a>
        </div>
      </div>
    </div>
  );
};

export default Home;

Projects Page with Filtering - src/pages/Projects.jsx

import React, { useState, useEffect } from 'react';
import axios from 'axios';

const Projects = () => {
  const [projects, setProjects] = useState([]);
  const [filter, setFilter] = useState('all');
  const [loading, setLoading] = useState(true);

  const categories = ['all', 'Cloud', 'DevOps', 'Web Dev', 'Embedded'];

  useEffect(() => {
    const fetchProjects = async () => {
      try {
        // Replace with your actual API endpoint
        const response = await axios.get('http://localhost:3001/api/projects');
        setProjects(response.data);
      } catch (error) {
        console.error('Error fetching projects:', error);
        // Fallback sample data
        setProjects([
          {
            id: 1,
            title: 'Cloud Infrastructure Automation',
            description: 'Scalable AWS infrastructure using Terraform and Kubernetes',
            category: 'Cloud',
            image: 'https://images.unsplash.com/photo-1451187580459-43490279c0fa?w=600&auto=format',
            technologies: ['Terraform', 'AWS', 'K8s'],
          },
          // Add more projects...
        ]);
      } finally {
        setLoading(false);
      }
    };

    fetchProjects();
  }, []);

  const filteredProjects = filter === 'all' 
    ? projects 
    : projects.filter(p => p.category === filter);

  return (
    <div className="min-h-screen bg-white dark:bg-gray-900 pt-24 pb-16">
      <div className="max-w-6xl mx-auto px-6">
        <h2 className="text-3xl font-light text-gray-900 dark:text-white mb-8">
          Featured Projects
        </h2>

        {/* Filter buttons */}
        <div className="flex flex-wrap gap-2 mb-10">
          {categories.map((cat) => (
            <button
              key={cat}
              onClick={() => setFilter(cat)}
              className={`px-4 py-2 rounded-full text-sm font-medium transition-colors ${
                filter === cat
                  ? 'bg-gray-900 text-white dark:bg-white dark:text-gray-900'
                  : 'bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700'
              }`}
            >
              {cat === 'all' ? 'All Projects' : cat}
            </button>
          ))}
        </div>

        {/* Projects grid */}
        {loading ? (
          <div className="text-center py-12">
            <div className="inline-block animate-spin rounded-full h-8 w-8 border-4 border-gray-300 dark:border-gray-600 border-t-gray-900 dark:border-t-white"></div>
          </div>
        ) : (
          <div className="grid grid-cols-1 md:grid-cols-2 gap-8">
            {filteredProjects.map((project) => (
              <div
                key={project.id}
                className="group bg-gray-50 dark:bg-gray-800 rounded-xl overflow-hidden hover:shadow-xl transition-all duration-300"
              >
                <div className="overflow-hidden">
                  <img
                    src={project.image}
                    alt={project.title}
                    className="w-full h-56 object-cover group-hover:scale-105 transition-transform duration-500"
                  />
                </div>
                <div className="p-6">
                  <div className="flex items-center justify-between mb-3">
                    <span className="text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
                      {project.category}
                    </span>
                    <div className="flex gap-2">
                      {project.technologies.slice(0, 3).map((tech) => (
                        <span
                          key={tech}
                          className="text-xs px-2 py-1 bg-gray-200 dark:bg-gray-700 text-gray-700 dark:text-gray-300 rounded"
                        >
                          {tech}
                        </span>
                      ))}
                    </div>
                  </div>
                  <h3 className="text-xl font-medium text-gray-900 dark:text-white mb-2">
                    {project.title}
                  </h3>
                  <p className="text-gray-600 dark:text-gray-400 text-sm mb-4">
                    {project.description}
                  </p>
                  <button className="text-sm font-medium text-gray-900 dark:text-white hover:underline">
                    View Case Study →
                  </button>
                </div>
              </div>
            ))}
          </div>
        )}
      </div>
    </div>
  );
};

export default Projects;

7. Main App Component

src/App.jsx

import React from 'react';
import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
import { ThemeProvider } from './context/ThemeContext';
import Navbar from './components/Navbar';
import ThemeToggle from './components/ThemeToggle';
import Home from './pages/Home';
import Projects from './pages/Projects';
import About from './pages/About';

function App() {
  return (
    <ThemeProvider>
      <Router>
        <div className="min-h-screen bg-white dark:bg-gray-900">
          <Navbar />
          <ThemeToggle />
          <Routes>
            <Route path="/" element={<Home />} />
            <Route path="/projects" element={<Projects />} />
            <Route path="/about" element={<About />} />
          </Routes>
        </div>
      </Router>
    </ThemeProvider>
  );
}

export default App;

🔌 Backend Integration

To make the portfolio dynamic, you can set up a simple Express backend:

server/index.js

const express = require('express');
const cors = require('cors');
const app = express();

app.use(cors());
app.use(express.json());

// Projects API endpoint
app.get('/api/projects', (req, res) => {
  const projects = [
    {
      id: 1,
      title: 'Cloud Infrastructure Automation',
      description: 'Scalable AWS infrastructure using Terraform and Kubernetes',
      category: 'Cloud',
      image: 'https://images.unsplash.com/photo-1451187580459-43490279c0fa?w=600&auto=format',
      technologies: ['Terraform', 'AWS', 'K8s'],
    },
    // Add more projects...
  ];
  res.json(projects);
});

app.listen(3001, () => {
  console.log('Server running on port 3001');
});

✨ Key Features Implemented

Dark/Light Mode Toggle - Persistent theme switching with system preference detection
Responsive Design - Mobile-first approach using Tailwind's responsive utilities
Project Filtering - Category-based filtering with smooth transitions
Loading States - Spinner indicators for async operations
Backend Ready - Axios integration for API calls
Smooth Animations - Hover effects and transitions
Clean Navigation - React Router with active link highlighting

🚀 Deployment

Build for Production

npm run build

Deploy to Vercel (Recommended)

npm install -g vercel
vercel

Deploy to Netlify

npm run build
# Drag and drop the 'dist' folder to Netlify

📈 SEO Optimization Tips

Add meta tags in index.html:

<meta name="description" content="Portfolio of Alex Chen - Software Engineer specializing in Cloud, DevOps, and Embedded Systems">
<meta name="keywords" content="software engineer, portfolio, cloud, devops, react, tailwind">

Use semantic HTML (header, main, section, article)
Add alt text to all images
Implement proper heading hierarchy (h1, h2, h3)

🎨 Customization Ideas

Add a blog section with MDX support
Implement a contact form with EmailJS
Add smooth scroll animations with Framer Motion
Include a resume download button
Add testimonials carousel
Implement portfolio item modals

📚 Resources

Tailwind CSS v4 Documentation
React Documentation
Vite Documentation
Unsplash - Free images for your projects

💡 Pro Tips

Performance: Use lazy loading for images and code splitting for routes
Accessibility: Ensure proper contrast ratios and keyboard navigation
Testing: Add unit tests for components using Jest and React Testing Library
Analytics: Integrate Google Analytics or Plausible for visitor insights

🎯 Conclusion

You've now built a modern, professional portfolio with cutting-edge technologies! This setup gives you:

✅ Lightning-fast development with Vite
✅ Beautiful, responsive design with Tailwind CSS v4
✅ Dark mode with system preference detection
✅ Dynamic content with API integration
✅ Clean, maintainable code structure

The best part? You can easily extend this foundation with additional features like a blog, case studies, or even an admin dashboard.

Ready to make it your own? Fork the code, customize the content, and deploy your portfolio today!

Found this guide helpful? Share it with your network! Have questions? Drop them in the comments below.

Tags: #React #TailwindCSS #Vite #WebDevelopment #Portfolio #Frontend #JavaScript #DevOps

This tutorial was originally published on Dev.to. Follow me for more web development content!

github: https://github.com/bkoimett/bkoimett-portofolio.git
linkedIn: https://www.linkedin.com/in/benjamin-koimett-699959366/

Pointers in Go: A Practical Guide for Developers

Benjamin Koimett — Tue, 03 Feb 2026 10:32:06 +0000

Understanding the Basics

Pointers in Go are often misunderstood by developers coming from languages that hide pointer complexity or don't have them at all. At their core, pointers are simply variables that store memory addresses rather than actual values.


var x int = 42
var ptr *int = &x  // & gets the address, *int declares a pointer type

Why Pointers Matter in Go

1. Performance and Memory Efficiency

When you pass large structs to functions, Go copies the entire struct by default. Pointers let you pass a reference instead:


type User struct {
    ID   int
    Name string
    // ... 20 more fields
}

// Inefficient - copies entire struct
func processUser(u User) {
    // ...
}

// Efficient - passes reference
func processUserPtr(u *User) {
    // ...
}

2. Modifying Function Arguments

Go passes arguments by value, meaning functions receive copies. To modify the original, you need pointers:


func increment(x int) {
    x++ // Only modifies the copy
}

func incrementPtr(x *int) {
    *x++ // Dereferences and modifies the original
}

func main() {
    val := 10
    increment(val)     // val is still 10
    incrementPtr(&val) // val becomes 11
}

3. Working with Methods

Go has both value and pointer receivers for methods, which affects mutability:


type Counter struct {
    value int
}

// Value receiver - works on a copy
func (c Counter) Get() int {
    return c.value
}

// Pointer receiver - can modify original
func (c *Counter) Increment() {
    c.value++
}

func main() {
    c := Counter{value: 5}
    c.Increment() // Go automatically converts to (&c).Increment()
    fmt.Println(c.Get()) // Output: 6
}

Common Pointer Patterns

The nil Pointer Check

Always check for nil pointers before dereferencing:
go

func printName(user *User) {
    if user == nil {
        fmt.Println("User is nil")
        return
    }
    fmt.Println(user.Name)
}

Pointer to Pointer (Rare but Useful)

Sometimes you need multiple levels of indirection:
go

func allocateMatrix(rows, cols int) **int {
    matrix := make([]*int, rows)
    for i := range matrix {
        row := make([]int, cols)
        matrix[i] = &row[0]
    }
    return &matrix[0]
}

Returning Pointers from Functions

Returning pointers to local variables is safe in Go thanks to escape analysis:
go

func createUser(name string) *User {
    return &User{Name: name} // Go allocates this on the heap
}

When to Use Pointers (and When Not To)

Use pointers when:

Structs are large (prevents copying)
You need to modify the original value
Working with methods that change receiver state
Dealing with optional parameters (nil pointer = not provided)

Avoid pointers when:

Working with basic types (int, bool, string) unless modification is needed
The struct is small (copying is cheaper than dereferencing)
You want immutability by default
Working with concurrency (pointers require careful synchronization)

Gotchas and Best Practices

1. Pointer Arithmetic is Not Allowed

Unlike C, Go doesn't allow pointer arithmetic for safety:
go

// This won't compile in Go
ptr := &arr[0]
ptr++ // Error: invalid operation

2. Maps and Slices are Already References

Maps and slices already contain pointers internally, so you often don't need pointers to them:
go


func modifySlice(s []int) {
    s[0] = 100 // Modifies the original slice
}

3. Interface Values Can Hold Pointers

When storing structs in interfaces, be aware of the pointer/value distinction:
go

type Speaker interface {
    Speak() string
}

type Dog struct{ name string }

func (d *Dog) Speak() string { return "Woof!" }

func main() {
    var s Speaker
    d := Dog{name: "Rex"}
    // s = d     // Error: Dog doesn't implement Speaker
    s = &d       // OK: *Dog implements Speaker
}

4. Use new() vs. Composite Literals

// Both are valid, but have different use cases
u1 := new(User)     // Zero-valued User, returns *User
u2 := &User{ID: 1}  // Initialized User, returns *User

Performance Considerations

Go's compiler performs escape analysis to determine whether variables should be allocated on the heap or stack. Don't prematurely optimize by using pointers everywhere - let the compiler do its job and profile your code first.

// The compiler will determine where to allocate
func createUser() *User {
    u := User{Name: "Alice"} // Might be stack or heap allocated
    return &u
}

Testing with Pointers

When testing functions that use pointers, remember that &User{} creates a pointer:
The key to mastering pointers is practice. Start with simple cases, understand when data is being copied versus referenced, and gradually work up to more complex patterns. Happy coding!

func TestProcessUser(t *testing.T) {
    user := &User{Name: "Test"}
    result := processUserPtr(user)
    // Test assertions
}

## Conclusion

Pointers in Go strike a balance between C's explicit memory control and higher-level language safety. They're essential for:

Writing efficient code with large data structures
Implementing mutable method receivers
Creating flexible APIs with optional parameters

Remember the golden rule: Use pointers when you need to share or modify data, otherwise prefer values. This approach gives you performance when needed while maintaining code clarity and safety.

The key to mastering pointers is practice. Start with simple cases, understand when data is being copied versus referenced, and gradually work up to more complex patterns. Happy coding!

Strings vs Slices: a Love Triangle with Characters 💔🧵

Benjamin Koimett — Thu, 29 Jan 2026 10:53:46 +0000

Every developer eventually stands at this crossroads:

“Do I treat this string like a civilized adult…
or do I slice it into little byte goblins and hope for the best?”

If you’ve ever printed "🙂" and got four mysterious numbers instead, congratulations—you’ve met UTF-8 in a dark alley.

Let’s break it down. No gaslighting. No sugar. Just facts, vibes, and a little brain rot.

Option 1: Treating strings as bytes

(a.k.a. “It works on ASCII, ship it”)

In languages like Go, a string is basically:

“Here’s a read-only bag of bytes. Do not ask questions.”

Pros

🚀 Fast. Like ‘blink and you missed it’ fast

🧠 Simple mental model

📦 No extra memory allocations

Perfect for:

Protocols
File formats
ASCII-only data
When performance is king and Unicode is a rumor

Cons

💥 UTF-8 will humble you
Slicing can split characters in half
(congrats, you’ve invented emotional damage)
Counting characters? ❌
You’re counting bytes. Very different beasts.

s := "Go🙂" fmt.Println(len(s)) // 6 (bro what?)

This is the programming equivalent of:

“I asked for vibes and got taxes.”

Option 2: Converting to rune slices

(a.k.a. “I respect human languages”)

Enter: []rune.

This says:

“I want characters, not byte soup.”

Pros

🌍 Unicode-safe

🧩 One rune = one character (mostly, calm down linguists)

✂️ Safe slicing, reversing, indexing

You won’t accidentally bisect an emoji like a psycho

r := []rune("Go🙂")
fmt.Println(len(r)) // 3 (nature is healing)

Cons

🐢 Slower (conversion costs)

🧠 More memory

Overkill if you know you’re dealing with ASCII

This is the “touch grass” option. Mature. Responsible. Slightly heavier.

So… which one is best? 🤔

Here’s the cold truth:

Neither is “best.” Context is king.

Use raw strings / bytes when:
You’re doing low-level work
Performance matters more than feelings
Input is guaranteed ASCII
You’re parsing, not presenting

Use rune slices when:

You’re manipulating text for humans
You care about correctness
Emojis, accents, or non-English text exist
You don’t want bug reports titled
“App deletes half my name 😭”

The Big Brain Take 🧠✨

Default to strings.
Switch to []rune the moment you manipulate characters.
Switch back when you’re done.

Yes, converting back and forth feels annoying.

So does debugging Unicode bugs at 2 a.m.
Pick your poison.

Final Thought (read in a dramatic narrator voice)

Bytes are fast.
Runes are safe.
Unicode is inevitable.

Choose wisely, or the emojis will unionize.

If this saved you from slicing an emoji in half, smash that like button, sacrifice a semicolon, and may your strings always be valid UTF-8.

Stay hydrated. Stay compiled. 🫡