Forem: Abdul Talha

My Technical Writing Portfolio

Abdul Talha — Tue, 07 Apr 2026 05:53:00 +0000

I created a technical writing portfolio to organise the work I have been doing in documentation, tutorials, and open-source contributions.

The goal was to bring together my writing in one place so developers and teams can easily explore my work.

The portfolio includes:

Articles published on freeCodeCamp
Tutorials on cloud deployments and developer tools
Technical writing samples and guides

Building this portfolio helped me reflect on the topics I enjoy writing about and the skills I want to continue improving.

I plan to keep updating the portfolio as I publish new articles and contribute to more open-source projects.

Portfolio: https://blog.abdultalha.tech/portfolio

How to Self-Host Affine on Windows Using Docker and WSL

Abdul Talha — Tue, 31 Mar 2026 05:42:00 +0000

I wrote a guide on how to self-host Affine on a Windows system using Docker and WSL.

Affine is an open-source workspace that combines note-taking, documentation, and project management in one place. Running it locally allows developers to experiment with the platform and understand how self-hosted applications work.

In this article, I walk through the full setup process for running Affine locally on Windows.

The guide covers:

Setting up Windows Subsystem for Linux (WSL)
Installing and configuring Docker
Running Affine using Docker containers
Accessing the self-hosted instance locally

The goal of this guide was to make the setup process simple and easy to follow for developers who want to explore self-hosting.

The article was published on freeCodeCamp and went through their editorial review process. I learned a lot from the feedback and revisions during this process.

You can read the full guide here:

https://www.freecodecamp.org/news/self-host-affine-on-windows-docker-wsl/

My Documentation Contributions to Codecademy’s Open Source Repository

Abdul Talha — Tue, 24 Mar 2026 05:58:00 +0000

I contributed to the open-source documentation repository of Codecademy.

During this work, I added five documentation entries while working through different issues in the repository. Each solu
tion was written in a separate branch in my fork so that the changes stayed organized.

While working on these issues, I focused on:

Understanding the structure of the documentation repository
Writing clear explanations for the requested entries
Following the contribution guidelines and workflow used by the project

All of the submissions passed the maintainer review process, which was a valuable learning experience.

However, before the pull requests could be merged into the main repository, the project was made a public archive. Once a repository is archived, maintainers can no longer merge new contributions.

Even though the changes were not merged into the main repository, the process helped me better understand how documentation contributions work in open-source projects.

You can see the work in my forked repository, where each issue was solved in a separate branch.

Repository:
https://github.com/abdultalha0862/docs

How Open Source Can Grow Your Tech Career – A Handbook for Beginners

Abdul Talha — Tue, 17 Mar 2026 05:02:00 +0000

Many beginners have heard about open source but it may be confusing at first.

When I first started learning programming, open source felt confusing. I didn’t clearly understand how projects worked or how contributing could help a developer grow.

To make this easier for beginners, I wrote a handbook explaining how open source works and how developers can use it to grow their tech careers.

In the handbook I covered topics like:

How open-source projects actually work
The roles of maintainers, contributors, and communities
Different ways beginners can contribute (not just code)
How open source builds skills, visibility, and career opportunities

While writing this handbook, I also tried to explain the real challenges beginners face and how they can approach their first contribution step by step.

This article went through the freeCodeCamp editorial review process, and I learned a lot from the feedback and revisions.

If you're a beginner who wants to understand open source and start contributing, this guide may help you take the first step.

Full handbook:
https://www.freecodecamp.org/news/open-source-career-handbook/

From Ghost to Zulip: Setting Up Zulip Locally on WSL2 (and Fixing Tricky Python Issues)

Abdul Talha — Thu, 18 Dec 2025 03:45:00 +0000

Introduction

After contributing to Ghost, I wanted to push myself further by working on a larger and more complex backend system.

That curiosity led me to Zulip, an open-source team collaboration tool known for its topic-based threading and production-grade architecture.

Zulip is built with:

Django
Tornado
PostgreSQL
RabbitMQ

Setting up Zulip locally isn’t hard, but it’s very different from a typical Django project. I ran into a few unexpected issues, especially around Python virtual environments and WSL configuration.

In this post, I’ll walk through:

How I set up Zulip locally on WSL2
The issues I faced during setup
How I fixed them, including the activate_this.py problem

If you’re new to Zulip or moving into larger backend systems, this guide should help you avoid common setup blockers.

Who This Post Is For

This post is for:

Developers contributing to Zulip for the first time
Open-source contributors moving beyond small projects
Anyone using WSL2 on Windows
Developers stuck with Python 3.12 or activate_this.py errors

Prerequisites

Before starting, make sure you have:

General

2GB+ RAM
Stable internet connection
GitHub account

Windows

Windows 10/11 (64-bit)
Virtualisation enabled (VT-x / AMD-V)
Admin access

Git and GitHub Setup

If Git is already configured, you can skip this section.

Generate an SSH key:

ssh-keygen -t ed25519 -C "your_email@example.com"

Copy the public key:

cat ~/.ssh/id_ed25519.pub

Add it to GitHub → Settings → SSH and GPG Keys.

Setting Up WSL2 for Zulip

If you already use native Ubuntu or WSL2, feel free to skip ahead.

Enable Virtualisation

Make sure VT-x / AMD-V is enabled in BIOS.

Install WSL2

wsl --install

This installs Ubuntu automatically.

Enable systemd (Required)

Zulip relies on background services like PostgreSQL, Redis, and RabbitMQ.

Edit:

sudo nano /etc/wsl.conf

Add:

[boot]
systemd=true

Restart WSL:

wsl --shutdown

Install Required Services

Update your system:

sudo apt update && sudo apt upgrade

Install services:

sudo apt install rabbitmq-server memcached redis-server postgresql

RabbitMQ Configuration

sudo nano /etc/rabbitmq/rabbitmq-env.conf

Add:

NODE_IP_ADDRESS=127.0.0.1
NODE_PORT=5672

Cloning the Zulip Repository

Fork Zulip from GitHub, then clone your fork:

git clone --config pull.rebase git@github.com:YOURUSERNAME/zulip.git
cd zulip
git remote add -f upstream https://github.com/zulip/zulip.git

Running Zulip Locally

Install dependencies:

./tools/provision

Activate the virtual environment:

source .venv/bin/activate

Start the dev server:

./tools/run-dev

Visit:

http://localhost:9991

Common Issues I Faced (and How I Fixed Them)

Issue 1: Missing `activate_this.py`

Error

FileNotFoundError: No such file or directory ... activate_this.py

Why this happens

Zulip now uses uv, which doesn’t automatically create activate_this.py. Some scripts still expect it.

Fix

Manually create the file:

cat > .venv/bin/activate_this.py << 'EOF'
import os
import site
import sys

bin_dir = os.path.dirname(os.path.abspath(__file__))
os.environ["PATH"] = os.pathsep.join([bin_dir] + os.environ.get("PATH", "").split(os.pathsep))

base = os.path.dirname(bin_dir)
os.environ["VIRTUAL_ENV"] = base

site_packages = os.path.join(base, 'lib', 'python{}.{}'.format(*sys.version_info[:2]), 'site-packages')

prev = set(sys.path)
site.addsitedir(site_packages)
sys.real_prefix = sys.prefix
sys.prefix = base

new = list(sys.path)
sys.path[:] = [i for i in new if i not in prev] + [i for i in new if i in prev]
EOF

Issue 2: Django Not Found (Python 3.12)

Error

ModuleNotFoundError: No module named 'django'

Cause

Older scripts used:

sys.version[:3]

This breaks with Python 3.12.

Fix

Use:

'{}.{}'.format(*sys.version_info[:2])

Then rerun:

./tools/provision

What I Learned

Technical

Modern Python tooling like uv changes old assumptions
Understanding virtual environments helps with debugging
WSL2 + systemd setup is critical for backend services

Non-Technical

Large codebases require patience
Error messages usually point to the real issue
Open-source communities are incredibly helpful

Final Thoughts

Moving from Ghost to Zulip has been a rewarding step in my open-source journey.

Zulip’s setup may feel overwhelming at first, but once the environment is running, contributing becomes much smoother. If you’re stuck on setup issues like activate_this.py, you’re definitely not alone.

I hope this post helps you get unblocked.

Useful Links

Zulip GitHub: https://github.com/zulip/zulip
Zulip Dev Docs: https://zulip.readthedocs.io/en/latest/development/overview.html
Zulip Community Chat: https://chat.zulip.org
WSL Docs: https://docs.microsoft.com/en-us/windows/wsl
uv: https://github.com/astral-sh/uv

My Journey into Open Source: Learning, Contributing, and Growing

Abdul Talha — Mon, 04 Aug 2025 10:01:51 +0000

I had no idea how to get started with Open Source until I watched a simple video by Kunal.

Open Source is a fantastic way to develop software. Anyone, anywhere in the world, can see, use, and contribute to the code. It’s not just about writing code; it’s about collaborating to build something bigger.

After watching Kunal's video (What is Open Source & How to Start?) and learning from Saviner Puri’s “Learn in Public” approach, I took a notebook and jotted down all the helpful insights they shared. I felt excited and eager to try those ideas.

Then I faced a challenge: how do you select the right organization to contribute to? I felt overwhelmed and confused. This was my biggest obstacle.

That’s when I discovered the Google Summer of Code (GSoC) website. Their filters help you find organizations matching your tech skills. After reviewing many options, I found Rocket.Chat, which was a perfect fit for my background.

Throughout this journey, I learned some key lessons:

Learn tools like Git and GitHub to contribute effectively.
Choose contributions that align with your skills.
Start small with beginner-friendly tasks to build your confidence.
Above all, rely on the community and mentors; they make a significant difference.

Contributing to Open Source is not just about writing code. It involves working on real software, making connections that can lead to internships and jobs, leveraging your tech skills, and growing professionally. Sometimes, you might even get to speak at conferences or travel for events.

If you already contribute, what’s your story? I’d love to hear from you. Please share your thoughts and any feedback in the comments.

Beginner's Guide to Mastering Git and GitHub

Abdul Talha — Mon, 28 Apr 2025 14:53:46 +0000

blog.globalabdultalha.tech / beginners-guide-to-mastering-git-and-github

🚨 Perfecting My Web Layout (HTML + CSS + Semantic Tags) 🚨

Abdul Talha — Mon, 14 Apr 2025 18:30:00 +0000

The Struggle: 💪😓
I had an idea for a colorful and organized webpage layout, but my first design didn't match. The result was messy and unorganized, nothing like what I imagined!

Debugging 🐞🔍🛠️:

1️⃣ Initial Insight:

I took a closer look at my code and realized I wasn't using any semantic tags. My layout was just a combination of divs, making the design difficult to control.

2️⃣ Exploring Resources:

After watching a tutorial by CodeWithHarry on YouTube, I discovered that using semantic tags (like <header>, <main>, and <footer>) not only makes the HTML more meaningful but also helps structure the layout more effectively.

3️⃣ Breakthrough Moment:

I replaced my non-semantic tags with proper HTML5 elements, updated my CSS accordingly, and BOOM! My design transformed into exactly what I wanted. The improvement was night and day!

Lesson Learned: 📚✨
The moral of the story: Semantic tags bring both clarity and visual harmony to your web projects. They make your code more readable and your final design more polished.

📸 Attached:

Comparison screenshots: the first image shows the final design, and the second image displays the initial messy layout.

🤔 To My Network:

Who else has realized this after using semantic tags? What were your takeaways?

🚨 From Chaos to Card Perfection (CSS Journey) 🚨

Abdul Talha — Thu, 10 Apr 2025 15:37:00 +0000

The Struggle:
At first, I threw all my content together into a card layout with no structure, using just plain text and images. It looked cluttered and unappealing. 😣 My initial design felt more like a rough draft than something polished.
Debugging:
1️⃣ Initial Insight:
I recognized that my card design lacked visual hierarchy and an appealing background. The layout needed a revamp to engage users truly.
2️⃣ Exploring Resources:
After watching a detailed video tutorial, I discovered the value of layering design elements. I learned that starting with a strong background and well-defined outer layers could transform the overall look of the card.
3️⃣ Breakthrough Moment:
I began by setting a contrasting body background color to highlight the card. Next, I defined the card’s outer layer to create a distinct container. Then, I added all the essential components and refined each element’s style. BOOM! The evolution from a messy draft to a sleek, professional card was complete!
Lesson Learned:
Moral of the story: A step-by-step approach to layering design elements can dramatically enhance your layout. Don't be afraid to start over and learn from tutorials—it's all part of the creative process.
📸 Attached:
I have attached the screenshots of both the initial and final card designs.
🤔 To my network:
Who else has transformed their design by revisiting the fundamentals? What strategies did you use to upgrade your layouts?

🚨 From Chaos to Card perfection (CSS Journey) 🚨

Abdul Talha — Thu, 10 Apr 2025 12:30:00 +0000

The Struggle:

At first, I threw all my content together into a card layout with no structure—just plain text and images. It looked cluttered and uninviting. 😣 My initial design felt more like a rough draft than something polished.

Debugging Saga:

1️⃣ Initial Insight:

I recognized that my card design was missing visual hierarchy and an appealing background. The layout needed a revamp to truly engage users.

2️⃣ The Revelation:

After watching a detailed video tutorial, I discovered the value of layering design elements. I learned that starting with a strong background and well-defined outer layers could transform the overall look of the card.

3️⃣ Breakthrough Moment:

I began by setting a contrasting body background color to highlight the card. Next, I defined the card’s outer layer to create a distinct container. Then, I added in all the essential components and refined each element’s style. BOOM—the evolution from a messy draft to a sleek, professional card was complete!

Lesson Learned:

Moral of the story: A step-by-step approach to layering design elements can dramatically enhance your layout. Don't be afraid to start over and learn from tutorials—it's all part of the creative process.

📸 Attached:

Side-by-side screenshots of the initial and final card designs
Code snippet illustrating key style improvements

🤔 To my network:

Who else has transformed their design by revisiting the fundamentals? What strategies did you use to upgrade your layouts?

The Open Source Lessons I’m Sharing to Empower Fellow Developers

Abdul Talha — Wed, 09 Apr 2025 15:23:50 +0000

How to Approach Open Source Contribution Effectively

Focus on Impact, Not Quantity: Instead of measuring your contributions by the number of commits, prioritize meaningful fixes that deliver substantial value. Solving a critical issue effectively holds more weight than frequent, minor updates.
Start with the User Experience:Before diving into the codebase, prioritize setting up the product locally. Address obstacles you encounter during installation or configuration—these pain points often reveal high-impact areas for contribution.
Quality Over Frequency: Rather than aiming for daily contributions, focus on solving one genuine, challenging problem. It’s acceptable—even beneficial—to invest time in resolving complex issues, as these efforts demonstrate deeper expertise and create lasting value.
Document Your Journey: Share your open source contributions publicly (e.g., LinkedIn, X/Twitter) to create a knowledge base. This helps others facing similar challenges while establishing your thought leadership and expanding your professional network.

Opportunities Unlocked by Open Source Contribution

Career Advancement: Open source contributions showcase technical skills and collaboration abilities, making you a stronger candidate for promotions, leadership roles, or high-impact projects.
Freelancing/Consulting Opportunities: Demonstrated expertise in specific tools or ecosystems through open source work can attract clients seeking specialized skills, often at premium rates.
Global Recognition: Consistent, valuable contributions position you as a subject matter expert, opening doors to speaking engagements, conference invitations, and collaborative projects with industry leaders.

Post 1

Abdul Talha — Tue, 08 Apr 2025 15:44:01 +0000

This is the post 1