DEV Community: codewitgabi

Introduction to system design

codewitgabi — Fri, 15 Aug 2025 19:10:52 +0000

What is system design?

System design is the process of defining the elements of a system, as well as their interactions and relationships, in order to satisfy a set of specified requirements.

It involves taking a problem statement, breaking it down into smaller components and designing each component to work together effectively to achieve the overall goal of the system.

What does this mean? System design is that planning stage in software engineering where you design the flow, patterns, architecture of how the system you're trying to build becomes functional and efficient, taking better steps to build a better system. So you're asked to build an authentication system and yeah, you probably already know how to build one but those that actually satisfy the requirement of the project? This is the very big question to ask as a software engineer designing a system. It starts from as little as the language, framework to use.

How do I approach system design?

This is a very important question and I'll be going through a few steps as to how you can approach it and build a better system

Understand the problem:
This is the most important stage of all. Most software engineers jump right into building a solution without actually understanding the problem it is trying to solve and also the use case. You want to make sure you understand the problem brought before you down to the last detail before you start proffering solutions especially during interviews as this is one of the stages of the interview process and a determining one at that. Be sure to ask a lot of questions to understand what problem you're going to be solving and then you can start bringing in those solutions.
Identify the scope of the system:
This still falls under understanding the problem. You should try and get the scope of the system in the sense that building an authentication system for a blog application is different from building one for a fintech application. A blog application does not necessarily need 2FA (Two-factor authentication) but a fintech definitely does. But now, there are some blog applications that may require one and that is why you need to identify and understand the scope of the system you're trying to build.
Create a high-level design:
A diagram is necessary if this is going to be a long term project and not just an interview process as this will help future engineers to understand the system and how it works. As you keep improving the system, be sure to improve the design. If necessary, version it for high end maintainability.
Continuously monitor and improve the system:
Now, you don't want to just build a system and assume everything is perfect. I don't think there will ever exist a perfect system so you would want to monitor it and see ways it can be improved. This should be done from continuously.

This is just an introduction to my series on system design. I will be dropping some system design concepts in the next one.

Get windows 11 activation key and activate windows

codewitgabi — Mon, 19 Aug 2024 18:29:58 +0000

Do you currently face the issue where your windows activation key is expired and then you need to activate it? Tired of that regular popup asking you to activate your windows? Let me show you how to do that in less than 2 minutes.

Open the command prompt

Open the command prompt on your desktop by typing cmd on the search bar. Open it in Run as Administrator.

You should have something that.

You should have a black screen popup. In there, just type the below command or copy and paste it.

wmic path SoftwareLicensingService get OA3xOriginalProductKey
OA3xOriginalProductKey

Once that's done, your activation code will be printed right there on the command prompt.

Next step

The next thing to do is to go to settings and activate your windows. Click on your search bar and type settings.

Click on Activation and Change product key. Enter your generated activation key there and click next.

Boom!!! That's all you need to do to activate your windows. Don't forget to leave a thumbs up and a comment if it worked for you.

fastapi opensource project

codewitgabi — Sat, 03 Aug 2024 17:48:06 +0000

Hello world!! It's been a while.

I have been so engrossed with my intership at hng and it has been a wonderful experience, learning a lot of standard conventions to use while coding, best practices to follow when creating commits and pull requests etc.

One of my most amazing experiences was when most of the interns were asked to switch stack. I was on the backend track and already familiar with django and express but django wasn't among the required stack for the project we were working on. The preferred stack was fastapi. We had to learn fastapi in two to three days. It was cool since most of us were already used to the pressure of learning tools at such short timeframe.

Learning fastapi was one thing but then I always ask myself - how good will I be with this new framework? There is a quick and easy was to learn a tool and master it quickly and that's by building projects. With that in mind, I decided to start a fastapi open source project that covers most backend concepts and majority of what could be found in the official documentation

With this project, contributors will be able to

Understand the workflow of fastapi
Understand how to make queries
Write unittests using pytest
Write efficient PRs and issues

Here is the link to the project https://github.com/codewitgabi/full-featured-social-media-application-fastapi. A star wouldn't be too much to ask from you and more than that, I would love to have you as a contributor so 'we' can learn a few coding tricks from you.

Database design for backend engineers

codewitgabi — Sat, 27 Jul 2024 00:52:40 +0000

Often times, as backend engineers, we jump into writing our database schemas/models without properly planning what they will look like and this leads to more and more migration files been generated.

For some of us, we stick to using pen and paper which is quite cool but then we may have no reference to them in the future or how then do we share those designs with future backend engineers who will work on the project (...cause you may not be working on that project forever.)

Allow me to introduce DBML to you; DBML (Database Markup Language) is an open-source DSL language designed to define and document database schemas and structures. It is designed to be simple, consistent and highly-readable.

It also comes with command-line tool and open-source module to help you convert between DBML and SQL. - dbml

What does dbml look like?

On the left, we have the dbml syntax and be the right, we have the db diagram.

With this, you can share with your team members and also have reference for future developers to quickly know what's really going on in the database aspect of your application.

DBML is quite easy to learn. No need for long tutorials. All you need is the doc and you're set to write those beautiful database designs.

Why should I use dbml?

For collaboration with team members
Nice looking design to quickly comprehend relationship between tables, db columns, etc
Backend developers often find it difficult showcasing their skills to employers....this should serve as something to have in your portfolio
You could easily convert these into sql syntaxes

I hope you enjoyed this tutorial? If so, leave a reaction else leave a comment in the comment section. Thanks for reading.

Database migrations inconsistency in django

codewitgabi — Fri, 28 Jun 2024 19:07:09 +0000

Working with django can be really cool until you bumb into migrations inconsistency.

Migrations inconsistency happens when there is a rapid change in your models. Say, field altering, or change of table name. A quick fix is to probably delete the migration files, re-makemigrations and then migrate which may or may not work. Another try is to delete the database which would be tempting to do but then what if you are working on a production database. Of course, that's not a very nice approach to take.

This leads us to database backup. So, you have thought of everything but it seems deleting the database might be the best approach? No problem, all you need to do is backup the database and then as soon as a new one is created, you quickly inject the data back into the database.

Database backup with django

Django is a robust framework with batteries (lots of it), making it easier to perform database operations with its Object-Relational Mapper. Database backup is not an exemption. To backup your database, run the following commands.

python3 manage.py dumpdata > db-backup.json

Where db-backup.json is the name of the file that will contain your database data.

Reloading the database

To load the data back into the database, run the command below

python3 manage.py loaddata db-backup.json

And voila, you now have your "untampered" database

Just a brief info. Interships are a nice way to get your hands "dirty". hng is one place to get started for free and also hng-premium for a rich-full internship with lots of opportunities.

Messaging queues (Rabbitmq as broker)

codewitgabi — Sun, 16 Jun 2024 14:10:34 +0000

Since backend development goes beyond building CRUD applications, I am here to discuss one of the core concepts of backend development which is message queueing.

In DSA, queues are basically a structure that follow the FIFO (First In First Out) rule; meaning that the first element to be entered is the first to be processed just like queue in banks, shoprite etc.

A message queue is a form of asynchronous service-to-service communication used in serverless and microservices architectures. Messages are stored on the queue until they are processed and deleted. Each message is processed only once, by a single consumer AWS.

Today, I will discuss some things that need to be considered to have a kind of reliable server when using Rabbitmq as a message broker.

Message acknowledgement: Doing a task can take a few seconds, you may wonder what happens if a consumer starts a long task and it terminates before it completes. Basically, once our producer delivers a message to the consumer, it marks it for deletion. In this case, if you terminate a worker, the message it was just processing is lost. The messages that were dispatched to this particular worker but were not yet handled are also lost. If a worker dies, we'd like the task to be delivered to another worker. In order to prevent this from happening, Rabbitmq provides message acknowledgement. If a consumer dies (its channel is closed, connection is closed, or TCP connection is lost) without sending an ack, RabbitMQ will understand that a message wasn't processed fully and will re-queue it. If there are other consumers online at the same time, it will then quickly redeliver it to another consumer. That way you can be sure that no message is lost, even if the workers occasionally die.

To achieve this, do this

def callback(ch, method, properties, body):
    # your code
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback)

Message durability: We have learnt how to handle tasks when a worker is stopped. How do we handle them if our broker is stopped? When RabbitMQ quits or crashes it will forget the queues and messages unless you tell it not to. Two things are required to make sure that messages aren't lost: we need to mark both the queue and messages as durable. This should be done both for the producer and consumer (or worker).

channel.queue_declare(queue='queue_name', durable=True)

If you have already created a queue that's not durable, updating it won't change that so it's better to do that at the beginning

At that point we're sure that the task_queue queue won't be lost even if RabbitMQ restarts. Now we need to mark our messages as persistent - by supplying a delivery_mode property with the value of pika.DeliveryMode.Persistent

channel.basic_publish(
    exchange="",
    routing_key="queue_name",
    body=message,
    properties=pika.BasicProperties(delivery_mode=pika.DeliveryMode.Persistent),
)

Fair dispatch: By default, if we have multiple workers/consumers running, rabbitmq tries to share tasks to these workers evenly using the round-robin algorithm (RRA) but what if one worker is already done processing its task and the others are not done but because of RRA, it's not its turn so it becomes idle and the request is added to another worker that is processing a task. To fix this issue, you should use a fair dispatch in the worker.

channel.basic_qos(prefetch_count=1)

What is a stack?

codewitgabi — Sat, 15 Jun 2024 18:05:45 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Just like when you have crate of eggs or drinks placed one on top the other, you can't remove the one at the bottom else, you tend to scatter the whole arrangement. So you start with the one at the top (the last added crate) and then go all the way down.

What is a Queue?

codewitgabi — Sat, 15 Jun 2024 17:58:07 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

When you visit a bank or you go to the supermarket to get some groceries, you stay in line. The person in front of you gets answered first because he was there before you. That's basically a queue in computer science

What is memoization

codewitgabi — Thu, 13 Jun 2024 09:04:40 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Say I go to a store to get some groceries, the price of my items is calculated but then I decide to add a new item, the new price is added to the already calculated price instead of adding the price of every item again. That is memoization

How to efficiently use drf_social_oauth2 and django_rest_framework_simplejwt

codewitgabi — Thu, 13 Jun 2024 01:43:40 +0000

Hey guys!!

So I was working on a rest api application with django and django rest framework but then I happened to run into a lot of issues using drf_social_oauth2 and django_rest_framework_simplejwt. The issue was that the former strictly uses Bearer authentication header while the latter uses any authorization header of your choice so what I did initially was to use JWT for simplejwt. This worked fine even though on the client side, my team and I had to write some logic to know if the user initially logged in via oauth or regular auth. This was okay but I was not too comfortable with it. I later thought of a solution to fix the issue and today, I will be showing you what I did to fix this boring issue.

# settings.py
# before

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
        "oauth2_provider.contrib.rest_framework.OAuth2Authentication",
        "drf_social_oauth2.authentication.SocialAuthentication",
    ),
}

# settings
# after

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ),
}

So from the two code in our settings.py, you can see we had to remove the oauth2_provider and simplejwt authentication from the authentication classes and that's because we will no longer be using it to authenticate. We will default back to using simplejwt and that brings us to the next part.

# views.py

# builtin imports
from json import loads as json_loads
from datetime import datetime

from oauth2_provider.settings import oauth2_settings
from oauth2_provider.views.mixins import OAuthLibMixin
from oauthlib.oauth2.rfc6749.errors import (
    InvalidClientError,
    UnsupportedGrantTypeError,
    AccessDeniedError,
    MissingClientIdError,
    InvalidRequestError,
)

from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from django.contrib.auth import get_user_model

# third party imports
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.permissions import AllowAny
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken
from rest_framework.status import HTTP_400_BAD_REQUEST
from rest_framework.request import Request

from drf_social_oauth2.serializers import ConvertTokenSerializer
from drf_social_oauth2.oauth2_backends import KeepRequestCore
from drf_social_oauth2.oauth2_endpoints import SocialTokenServer


# user object
User = get_user_model()


class CsrfExemptMixin:
    """
    Exempts the view from CSRF requirements.
    NOTE:
        This should be the left-most mixin of a view.
    """

    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(CsrfExemptMixin, self).dispatch(*args, **kwargs)


class ConvertTokenView(CsrfExemptMixin, OAuthLibMixin, APIView):
    """
    Implements an endpoint to convert a provider token to an access token

    The endpoint is used in the following flows:

    * Authorization code
    * Client credentials
    """

    server_class = SocialTokenServer
    validator_class = oauth2_settings.OAUTH2_VALIDATOR_CLASS
    oauthlib_backend_class = KeepRequestCore
    permission_classes = (AllowAny,)

    def post(self, request: Request, *args, **kwargs):
        serializer = ConvertTokenSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        # Use the rest framework `.data` to fake the post body of the django request.
        request._request.POST = request._request.POST.copy()
        for key, value in serializer.validated_data.items():
            request._request.POST[key] = value

        try:
            url, headers, body, status = self.create_token_response(request._request)
        except InvalidClientError:
            return Response(
                data={"invalid_client": "Missing client type."},
                status=HTTP_400_BAD_REQUEST,
            )
        except MissingClientIdError as ex:
            return Response(
                data={"invalid_request": ex.description},
                status=HTTP_400_BAD_REQUEST,
            )
        except InvalidRequestError as ex:
            return Response(
                data={"invalid_request": ex.description},
                status=HTTP_400_BAD_REQUEST,
            )
        except UnsupportedGrantTypeError:
            return Response(
                data={"unsupported_grant_type": "Missing grant type."},
                status=HTTP_400_BAD_REQUEST,
            )
        except AccessDeniedError:
            return Response(
                {"access_denied": f"The token you provided is invalid or expired."},
                status=HTTP_400_BAD_REQUEST,
            )

        body = json_loads(body)

        if "error" in body:
            return Response(data=body, status=status)

        token = body.get("access_token")
        user = User.objects.filter(oauth2_provider_accesstoken__token=token)[0]

        refresh = RefreshToken.for_user(user)
        access_token = str(refresh.access_token)
        decoded_token = AccessToken(access_token)
        expiration_time = datetime.fromtimestamp(decoded_token["exp"])

        return Response(
            {
                "id": user.id,
                "first_name": user.first_name,
                "last_name": user.last_name,
                "middle_name": user.middle_name,
                "fullname": f"{user.first_name} {user.last_name}",
                "email": user.email,
                "phone": user.phone.as_e164,
                "profile_picture": (user.profile_pic.url if user.profile_pic else None),
                "refresh": str(refresh),
                "access": access_token,
                "expiry": expiration_time,
            },
            status=status,
        )

It's a lot but for now, just ctrl + c and ctrl + v. The code is from the official drf_social_oauth codebase, I'm just overriding it.

token = body.get("access_token") gets the access_token from the body after the social auth access token has been converted.
user = User.objects.filter(oauth2_provider_accesstoken__token=token)[0] gets the user that is associated with the token.

refresh = RefreshToken.for_user(user)
access_token = str(refresh.access_token)
decoded_token = AccessToken(access_token)
expiration_time = datetime.fromtimestamp(decoded_token["exp"])

Here is where we change things.
First, we create a simplejwt refresh token for the user. Then we get the access token and expiration_time of the token. This is the token that will be used by the user to authenticate views.

With this, everything is done. You can now authenticate using Bearer in the authentication header.

Django Query Expressions F()

codewitgabi — Thu, 21 Dec 2023 01:44:25 +0000

Creating queries in django can go from simple to complex. Queries can be calculated in two places;

Python side and
Database side.

Writing queries from the python side always seem like the easiest thing to do but in reality, it reduces the performance of our application. So if the performance of your application means anything to you, you should read this article to the end without missing a thing as it will help you write django queries like a pro.

Query expressions describe a value or a computation that can be used as part of an update, create, filter, order by, annotation, or aggregate. When an expression outputs a boolean value, it may be used directly in filters. There are a number of built-in expressions (documented below) that can be used to help you write queries. Expressions can be combined, or in some cases nested, to form more complex computations.

Django supports negation, addition, subtraction, multiplication, division, modulo arithmetic, and the power operator on query expressions, using Python constants, variables, and even other expressions.

Going forward, I assume you're already familiar with the basics of django.

# app. models

class Company(models.Model):
    name = models.CharField(max_length=300)
    num_employees = models.IntegerField(default=0)
    num_chairs = models.IntegerField(default=0)
    is_registered = models.BooleanField(default=False)

    class Meta:
        verbose_name_plural = "Companies"
        db_table = "Company"
        indexes = [
            models.Index(fields=["name", "is_registered"])
        ]
        constraints = [
            models.CheckConstraint(check=models.Q(num_employees__gte=0), name="num_employees_gte_0"),
            models.CheckConstraint(check=models.Q(num_chairs__gte=0), name="num_chairs_gte_0")
        ]

    def __str__(self) -> str:
        return self.name


class Product(models.Model):
    class Meta:
        db_table = "Product"
        indexes = [
            models.Index(fields=["name", "price", "company"])
        ]
        constraints = [
            models.CheckConstraint(check=models.Q(price__gte=0), name="price_gte_0")
        ]

    name = models.CharField(max_length=100)
    company = models.ForeignKey(Company, on_delete=models.CASCADE)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self) -> str:
        return self.name

The F() query expression is used to query objects based on a model's field or its ForeignKey. It can be used to update model objects, filter queries if it returns a boolean value, etc. It makes it possible to refer to model field values and perform database operations using them without actually having to pull them out of the database into Python memory.

F() therefore can offer performance advantages by:

getting the database, rather than Python, to do work
reducing the number of queries some operations require

Some examples

# Find companies that have more employees than chairs.
Company.objects.filter(num_employees__gt=F("num_chairs"))

In the above event, the Company was filtered based on its field(num_chairs).

companies = Company.objects.filter(num_employees__lt=F("num_chairs")).annotate(workers_needed=F("num_chairs") - F("num_employees"))

The above query filters the Company object to those whose employees are less than the chairs they have in which case they want to get the number of seats to be filled. If this were to be done without the F() expression, that'd be a lot of computations.

Say the company wants to increase the prices for all its products. An easy way to do that will be;

Product.objects.update(price= F("price") + 150)

Which is better than

for product in Product.objects.all():
    product. price += 150
    product. save()

Updating a single object

product = Product.objects.first()
product.price = F("price") + 150
product.save()

F() assignments persist after Model.save()

F() objects assigned to model fields persist after saving the model instance and will be applied on each save(). For example:

product = Product.objects.first()
product.price = F("price") + 150
product. save()

product.name = "New name"
product.save()

The product's price will be updated twice in this case. If it’s initially 50, the final value will be 450. This persistence can be avoided by reloading the model object after saving it, for example, by using refresh_from_db().

product = Product.objects.first()
product.price = F("price") + 150
product. save()
product.refresh_from_db()

product.name = "New name"
product.save()

Using F() with logical operations

This happens to be my favorite part as it allows you to toggle boolean values.

company = Company.objects.first()
company.is_registered = ~F("is_registered")
company.save()
company. refresh_from_db()

If the value of is_registered is True, it changes it to False and vice versa.

That would be all for this part, see you on the next.

Hosting your django project on vercel: A quick and easy deployment

codewitgabi — Sun, 30 Jul 2023 20:24:25 +0000

Building django projects have always been fun for me until it gets to deploying them. In the past, Heroku was used but then just when I started learning to build django applications, it stopped it's free tier so I had to find an alternative. Looking for an alternative, I found out about Railway where I've hosted a lot of my projects but then, there was also a problem. After three months, I'd have run out of my free tier which means I either need to delete my account or ... Then I started learning how to deploy my django projects to vercel which I did and that's what I'm going to share in this post.

ElephantSQL

Most times, our backend requires a database and vercel does not support using the default dbsqlite3 and they do not provide a database for use so we will be using ElephantSQL for hosting our database.

Creating accounts

Since we will be using two platforms for our hosting, it will be nice to get started by creating an account.

Create vercel account here. It will be best to signin using your github account to ease deployment.
Create elephantsql account here.

Configuring our django project

Our django application will need some tweaking to work well on vercel so follow the steps below.

Create a build_files.sh file

Create a file named build_files.sh which will contain shell commands to build our project. Add the following lines of code to it.



# build_files.sh

pip install -r requirements.txt
python3.x manage.py collectstatic --no-input --clear

The version of python to be specified should be the one used in your django project.

Vercel.json

This is the configuration file that tells vercel about our django project.




{
  "version": 2,
  "builds": [
    {
      "src": "your_project/wsgi.py",
      "use": "@vercel/python",
      "config": {"maxLambdaSize": "15mb", "runtime": "python3.x"}
    },
    {
      "src": "build_files.sh",
      "use": "@vercel/static-build",
      "config": {
        "distDir": "staticfiles"
      }
    }
  ],
  "routes": [
    {
      "src": "/(.*)",
      "dest": "your_project/wsgi.py"
    },
    {
      "src": "/static/(.*)",
      "dest": "/static/$1"
    }
  ]
}

Copy and paste this in your vercel.json file and don't forget to change your_project to your original project name which is the name of the directory containing the wsgi.py file.

Also, remember to state the python version vercel should use for your project instead of python3.x

Next, we will make a little change to our wsgi.py file to let python know about our wsgi application.



### project/wsgi.py

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Quiz.settings')

application = get_wsgi_application()

# vercel config

app = application # add this line.

This is the last step we'll take and that will be in our project's settings.py file.



### project/settings.py

import os
import dj_database_url

SECRET_KEY = os.environ.get("SECRET_KEY")

DEBUG = os.environ.get("DEBUG") != "False"

ALLOWED_HOSTS = [".vercel.app", ".now.sh"]

INSTALLED_APPS = [
    "whitenoise.runserver_nostatic"
     # Other apps ....
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    "whitenoise.middleware.WhiteNoiseMiddleware",
    # other apps ...
]


DATABASES = {
    'default': dj_database_url.parse(
        os.environ.get("DATABASE_URL"),
        conn_max_age=600,
        conn_health_checks=True,
    )
}

STATIC_ROOT = os.path.join(BASE_DIR, "staticfiles", "static")

After this is done, be sure to install the following packages in your project's environment.

dj_database_url
whitenoise
psycopg2-binary

Ok your terminal/command prompt, run this command.



$ pip freeze > requirements.txt

Once that is done, push to github and then head over to vercel.

Create a new project and then import the project from your github. Once that's done, create the SECRET_KEY, DEBUG environment variables. Head over to ElephantSQL and create a database. Copy the database url and add it to your environment variables as DATABASE_URL.

Once that's done, click on the Deploy button and your project should display in less than 30secs. Head over to the provided domain and your side should be live. Let me know in the comment section if you faced any issue and I'll be glad to help.

Update Vercel recently updated their node version to 20.x so django does not currently work with that node version. You would probably get an ImportError message. To fix that issue, follow the steps below.

On your project homepage, similar to the one in the image below, click on settings.

From there, scroll to the bottom until you see Node.js version, change it to 18.x

That should be all unless you're doing something wrong then you should go through the tutorial again.