DEV Community: Rouwel Ngacha

How the python package installer works

Rouwel Ngacha — Sun, 26 Jul 2026 09:11:16 +0000

My first encounter with pip was trying to run a Python script that imported the requests library, only to be met with an import error. The fix turned out to be straightforward: using pip, Python's package installer.

To use pip, you need to have Python installed on your system. The basic command to install any library is:

pip install <package-name>

Best Practice: Using a Virtual Environment (`venv`)

Before installing packages everywhere, it’s best to create an isolated workspace for your project called a virtual environment. This keeps package dependencies for different projects separate so they don't clash with each other or your system's main Python installation.

1. Create the environment

Open your terminal in your project directory and run:

python -m venv venv

(This creates a folder named venv containing a standalone copy of Python and pip.)

2. Activate the environment

Before installing anything, activate it:

Windows:

  venv\Scripts\activate

macOS / Linux:

  source venv/bin/activate

Once activated, your terminal prompt will show (venv) at the beginning. Any pip install commands you run now will stay inside this isolated environment.

Bulk Installing Dependencies with `requirements.txt`

When you're running a Python script with multiple required packages, installing them one by one gets tedious. You can streamline this process by bulk installing everything at once using a requirements file.

Step 1: Create a `requirements.txt` file

Create a standard text file named requirements.txt in your project folder and list all your dependencies, one per line:

requests
pandas
numpy

Step 2: Run the bulk install command

With your virtual environment active, run:

pip install -r requirements.txt

Specifying Package Versions

Sometimes, the newest version of a library breaks compatibility with other packages in your project. To prevent this, you can specify exact version numbers directly inside your requirements.txt:

requests==2.31.0
pandas>=2.0.0
numpy<=1.24.0

== installs an exact version.
>= or <= sets a minimum or maximum allowed version.

From Arcade Cabinets to AI: How the GPU Changed Computing Forever

Rouwel Ngacha — Thu, 23 Jul 2026 19:55:48 +0000

Before graphics processing units (GPUs) became the powerhouse chips driving modern video games, scientific simulations, and artificial intelligence, computer graphics were slow, blocky, and severely limited. Understanding how we got from simple glowing dots to today's hyper-realistic 3D worlds requires looking back at a few key breakthroughs in computing history.

Part 1: In the Beginning — Legacy Systems & Early Graphics

1950: The Whirlwind Computer

The long story of computer graphics begins in 1950 with The Whirlwind, a giant computer built for the U.S. Navy as a flight simulator. Powered by thousands of bulky vacuum tubes, Whirlwind could perform around 50,000 basic calculations per second.

It commanded a cathode-ray tube (CRT) monitor to draw basic dots, shapes, and screen coordinates. While impressive for its time, Whirlwind wasn't actually an ancestor of the modern GPU—it was simply an early milestone showing that computers could display visual information.

1970s–1980s: The Arcade Era

The true lineage of the modern GPU started in arcade cabinets during the 1970s and 1980s.

Arcade Hardware: Arcade machines (like those running Pac-Man, Donkey Kong, or Galaga) used specialized graphics chips designed for "fixed functions". These chips were custom-built to quickly animate moving characters (sprites) and background tiles.
Home PCs: In contrast, early personal computers relied entirely on their Central Processing Unit (CPU) to draw graphics using software. Because CPUs had to process every single pixel alongside normal system operations, home computer graphics lagged far behind arcade performance.

The fixed-function design of arcade hardware—doing one visual job extremely fast—became the blueprint for dedicated graphics hardware.

Part 2: The 3D Revolution & Standardizing the Pipeline

How Early GPUs Worked: The Fixed Function Pipeline

In the late 1980s and 1990s, computer graphics shifted from 2D sprites to 3D virtual environments made up of triangles. This created a multi-step pipeline:

Game Engine: Determines the positions of 3D objects made of connected triangles.
CPU: Calculates game physics, rules, and coordinate movements.
GPU (or 3D Accelerator): Turns those 3D triangle coordinates into colored pixels.
Display: Sends the finished 2D image out to your monitor.

[ Game Engine ] ──► [ CPU: Physics & Logic ] ──► [ GPU: 3D to Pixels ] ──► [ Display ]

The Early Limitation: The API Wars

In the mid-1990s, every graphics card manufacturer created its own custom instruction language, known as an Application Programming Interface (API).

If a developer wanted their game to run on different graphics cards, they had to write separate versions for proprietary formats like 3dfx Glide, S3 Metal, PowerVR, or OpenGL. This fragmenting made developing 3D games difficult and expensive.

Part 3: The 1990s — Coining the "GPU" and Finding a Standard

Key Milestones of the 1990s

1993 (3dfx Voodoo & Glide API): 3dfx introduced the Voodoo card, delivering unprecedented 3D graphics performance for games like Quake. Its proprietary Glide API dominated the market, but only worked on 3dfx hardware.
1994 (Sony PlayStation): Sony began using the term "GPU" to describe the custom 32-bit graphics processor inside the original PlayStation console.
1998 (DirectX 7 & T&L): Microsoft released DirectX 7, featuring Transform & Lighting (T&L) technology. DirectX established a universal software standard across all graphics cards, effectively ending the API wars and rendering proprietary formats like Glide obsolete.
1999 (NVIDIA GeForce 256): NVIDIA popularized the term "GPU" for PC hardware by launching the GeForce 256. It was marketed as the world’s first true GPU because it took over visual geometry calculations entirely from the CPU.

Key Takeaways

Arcade roots: Specialized graphics chips began in arcades to offload visual work from general-purpose CPUs.
The 3D transition: As games moved to 3D, dedicated cards were required to handle complex math involving thousands of triangles.
Standardized software: Microsoft DirectX unified how games talk to graphics hardware, setting the stage for modern PC gaming and computing.

Using controllers to play Pc games

Rouwel Ngacha — Sun, 19 Jul 2026 19:16:02 +0000

For most of my life, I was convinced that you absolutely needed a console to play video games—whether we're talking about massive AAA blockbusters or hidden indie gems. Fortunately, I crossed paths with a few gamers who completely shattered my understanding of how gaming hardware works.

That realization opened up a whole new world. I started using my trusty 8th Gen I5 laptop at the time to play games, and my mind was officially blown. Fast forward to today: I’ve upgraded to a much better PC setup, and I'm fully enjoying the PC gaming experience the best way I know how—with a controller in hand.

Specifically, I use a PlayStation DualShock 4 (DS4) controller. But if you're diving into this without prior insight, trying to connect a console controller like a PS3 or PS4 pad to a PC can feel incredibly daunting. It isn't always plug-and-play out of the box.If you are ready to make the switch, here is your tutorial on how to use your controller on PC.

Prerequisites

1. DS4Windows
While there are a few different pieces of software out there designed to bridge the gap between a Windows PC and a PlayStation controller, DS4Windows is by far the most reliable tool for the job. You can get started by grabbing the software from the Official DS4Windows Site.

2. ViGEmBus.
Once you have the app, you will need to install the ViGEmBus (Virtual Gamepad Emulation Bus) driver. Don't worry, DS4Windows will actually prompt you to install this during the initial setup. This crucial kernel-mode driver runs silently in the background and allows the software to create "virtual" controllers that your PC can actually communicate with.

3. Emulation Profile Selection.
Because most Windows games natively expect an Xbox controller layout (XInput), this clever software tricks your PC into thinking your PlayStation pad is a native Windows device. Once your controller is connected, you can go into the profile settings and choose between whether you want to play as an Xbox 360 controller or a PS4 controller, giving you instant compatibility across almost every game on the market.

And that is how to use you playstation 4 controller to play pc games. Thanks for reading and happy playing.

Getting Started with Django: From Zero to 70% in Record Time . Step 1 :Starting phase (For Linux this time)

Rouwel Ngacha — Sat, 23 May 2026 20:05:31 +0000

Quick disclaimer (the post below is meant to mirror the previous post but for the Linux operating system. Please try to implement these methods and if they do not work on your machine leave a comment and allow me to find a solution.)

For this post, I would like to help anyone who is not familiar with Django to get somewhat of an understanding on how to use it to get from 0 to maybe 70% completion of a project in record time.
The objective today is to learn how to start, after 2 posts you should be able to speedrun projects.

First things first, you have to understand that there are multiple Python frameworks out there(Flask, FastAPI). The choice of which one to use is always up to you and the constraints on the project your working on.

With that being said let's dive in.

Step 1: Ensure that you download Python
For my device I am using Windows Subsystem For Linux (for more information : https://learn.microsoft.com/en-us/windows/wsl/install) this allows me to run an Linux Ubuntu terminal on my machine.
For the installation we will use apt (Advanced Package Tool) to install python3.
1.sudo apt update
2.sudo apt install python3

Step 2: Ensure you have to have Django installed
To install Django we will be using pip(a python package installer) which means you should have Python downloaded and configured in your path.

Something else I would like to encourage is the use of a Python virtual environment. You may not be familiar with this concept but trust me - there is not better time to learn how to use it.
The idea behind it is that, you install all your python packages while inside your project environment and as long as you initialize your environment all your project dependencies will work (eg Django, pillow). Sounds good?

Considering that we are on Linux we will need to download the specific packages that we want to use ( eg venv) in order to get our virtual environments active.
This is because unlike windows, downloading python3 does not come with the venv package already installed.
This means that if you try to run python3 -m venv MyProject
you will be met by an error.

So for every individual package we want to use we will have to install it as we go along.
1.sudo apt install python3-venv

From here we create and activate the project environment using
python3 -m venv Project and source Project/bin/activate

Now that you are in your environment, use pip to install Django.

Step 3: Creating a project
So to start a project the command is django-admin startproject ProjectName

Once you ran this command, it will create a folder where there are a few preconfigured python code files inside.

(Pre-configured project files)

Now that we have created a project, we will need to initialize a Django app while inside that folder. The command is
python3 manage.py startapp <name_of_your_app>

Now once you open your IDE, you will realized that you have a few code files inside your NewProject folder.

Step 4: Running the server
The final part of this post focuses on how to run the server. In later entries we will dive deeper and create a small-scale working example using all of Django's extensive features, but that is for later.

To run the server use python3 manage.py runserver.

So when you go to localhost at port 8000 you will find

And there you have it! You have successfully installed Django, created a project, initialized an app, and got your development server running (on linux).
While this may seem like a small set of steps, this is the foundation that every Django project is built on.

Getting Started with Django: From Zero to 70% in Record Time : Step 1

Rouwel Ngacha — Thu, 21 May 2026 22:06:54 +0000

For this post, I would like to help anyone who is not familiar with Django to get somewhat of an understanding on how to use it to get from 0 to maybe 70% completion of a project in record time.

So first you have to understand that there are multiple Python frameworks out there(Flask, FastAPI). The choice of which one to use is always up to you and the constraints on the project your working on.

With that being said let's dive in.

Step 1: Ensure you have to have Django installed
To install Django we will be using pip(a python package installer) which means you should have Python downloaded and configured in your path.

(Creating a folder and checking if python is installed)

Something else I would like to encourage is the use of a Python virtual environment. You may not be familiar with this concept but trust me - there is not better time to learn how to use it.

The idea behind it is that, inside that environment you can install all you python packages while inside the environment and as long as you initialize your environment all your project dependencies will be inside. Sounds good?

(Creating a python environment)

Now that you are in your environment, use pip to install Django.

Step 2: Creating a project
So to start a project the command is django-admin startproject projectname

Once you ran this command, it will create a folder where there are a few preconfigured python code files inside.

(Pre-configured project files)

Now that we have created a project, we will need to initialize a Django app while inside that folder. The command is python manage.py startapp

Now once you open your IDE, you will realized that you have a few code files inside your NewProject folder.

Step 3: Running the server
The final part of this post focuses on how to run the server. In later entries we will dive deeper and create a small-scale working example using all of Django's extensive features, but that is for later.

To run the server use py manage.py runserver.

So when you go to localhost at port 8000 you will find

And there you have it! You have successfully installed Django, created a project, initialized an app, and got your development server running. While this may seem like a small set of steps, this is the foundation that every Django project is built on.

Device drivers : The Unsung Heroes of Your Computer

Rouwel Ngacha — Thu, 14 May 2026 18:29:00 +0000

You have probably never heard of device drivers, but without them, you would not be able to use your computer.

So picture your computer

— you can see the keyboard, the touchpad, the power button, maybe a fingerprint sensor, and a touchscreen. For all of that hardware to function (for the keyboard to actually put letters on the screen, for the mouse to actually move and click items, for your touchscreen to work), something has to bridge the gap between the physical components and the operating system. That something is called a device driver.

Device drivers are essentially the compatibility layer between a device's hardware and its software.

On Windows, the graphical interface for managing drivers is called Device Manager. It is accessible by right-clicking the Windows icon and selecting "Device Manager" from the pop-up menu, and it looks like this:

On the popular Linux distribution Ubuntu, the equivalent interface looks like this:

But we are just scratching the surface.
To recap: every piece of hardware on a system requires a driver to function as intended. This includes externally connected devices.
A good example is a printer — to use one, you first connect it to your system (laptop or desktop). In many cases, your operating system will automatically detect and install the necessary drivers for you. However, if it does not, you can manually download and install them from the manufacturer's website.

Unused Potential: Disabling and or Deleting Drivers
This brings me to a lesser-known but useful aspect of drivers. Just as you can download and install them, you can also disable or delete them. This might sound counterproductive at first, but there are situations where it becomes a practical solution.
A problem I recently encountered was my laptop's touchscreen registering phantom presses in one corner of the screen on its own. I had two options:

Option 1 — Pay to have it repaired, which is the best long-term solution.
Option 2 — Disable the touchscreen driver entirely to stop the erratic behavior.

Since the touchscreen is not essential to how I use my laptop, I chose to disable it. The names of all the drivers and how they affect your computer are available online, so it is advisable to search first and confirm that what you want to do is safe and achievable before proceeding.

Always remember that messing with the wrong drivers could have serious consequences, such as losing Wi-Fi connectivity or being unable to use your keyboard. That said, the choice is always yours to make based on your own needs and priorities.

the CSRF token

Rouwel Ngacha — Mon, 11 May 2026 18:39:13 +0000

Hello world, my name is rrouwelng and I am here to talk about the CSRF token.

So, what is a CSRF token? A Cross-Site Request Forgery token is a unique and unpredictable value generated by server-side application. This was developed as a countermeasure to the Cross-Site Request Forgery attack that was first documented in the early 2000's.

What is a Cross-Site Request Forgery attack ? Allow me to give an example.

This is Bob,

Bob, logs into his bank at

Bob then decided to go read an article at a certain website at

Please note that Bob hasn't logged out of his bank account.

The site 'welikekittens.com' is set up by a malicious actor(call him swipper).

The website(welikekittens.com) is set up to send a form that is just a POST request to Bob's bank website that basically tells it to credit a certain amount of money to the account of the attackers choosing.

Because of how browsers work, every request(GET, POST or otherwise ) sent from bob's browser to the bank's server has the authentication cookies that Bob was given when he logged into the bank. This includes requests that weren't sent by Bob himself and are being sent by the malicious site.

To counteract this, Bob's bank decides to use a CSRF-Token. When Bob interacts with the Bank interface, he receives a CSRF token that is embedded on the page. So now, if welikekittens.com tries to send a request from bob's browser, the bank's server checks the form to see if the CSRF token is included in the form.

Since it is not included the request is automatically denied because the request doesn't include the CSRF token. As a bonus because of the Same-Origin Policy(basically means that one website cannot read the contents of another website unless they are from the same host. Feel free to look it up) welikekittens.com is unable to see the token and bob's bank account is safe for now.

And that is CSRF tokens in a nutshell, feel free add or discredit what I have written (with proof of course :) ).