DEV Community: Joshua Hassan

🚀 WSGI vs ASGI — Sync vs Async in Python Web Development (Made Simple)

Joshua Hassan — Mon, 07 Apr 2025 12:02:06 +0000

Written with the assistance of AI (ChatGPT)

🧠 The Basics

If you're building web apps with Flask, Django, or FastAPI, you've probably heard terms like:

WSGI
ASGI
Sync
Async
Blocking
Non-blocking

But what do these actually mean for you as a developer?

Let’s break it down — simply.

🔄 WSGI vs ASGI

When building web apps in Python, WSGI (Web Server Gateway Interface) and ASGI (Asynchronous Server Gateway Interface) determine how requests are handled and how your server communicates with your code.

WSGI is the traditional standard used by synchronous Python web frameworks like Flask and Django. It processes one request per thread, meaning it blocks the thread until that request is completed. This is fine for low-traffic apps but can cause slowdowns when handling many concurrent users.

ASGI, on the other hand, was introduced to support asynchronous operations and handle concurrency. It allows multiple requests to be processed at the same time using async/await. This makes it ideal for modern frameworks like FastAPI and Django Channels, which need to handle high traffic or tasks like real-time updates, long-running operations, or handling I/O-bound operations (e.g., database queries, API calls).

In simple terms:

WSGI: One thread, one request at a time.

ASGI: Multiple threads (or coroutines), multiple requests at once.

🧱 Synchronous (WSGI)

In a synchronous world (like using Flask), each request blocks the thread it's running on until it's done:

@app.route("/X")
def sync_x():
    time.sleep(5)  # Simulates a long task
    return "Done"

Problem:

User A calls /X → sleeps for 5 sec
During this, no other requests can be handled (on a single worker)
User B or C? They wait.

Unless you scale with multiple threads or processes, your app becomes slow under load.

⚡ Asynchronous (ASGI)

With frameworks like FastAPI, you can write non-blocking code using async def and await:

@app.get("/X")
async def async_x():
    await asyncio.sleep(5)  # Simulated non-blocking delay
    return {"message": "Done"}

Benefit:

User A hits /X and awaits
While waiting, the server handles User B and User C
All requests proceed without blocking each other

🧪 Real-World Scenario: 3 Users, Same Endpoint

SYNC Version (blocking):

from fastapi import FastAPI
import time

app = FastAPI()

@app.get("/sync")
def sync_endpoint():
    time.sleep(5)
    return {"message": "Sync response"}

ASYNC Version (non-blocking):

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/async")
async def async_endpoint():
    await asyncio.sleep(5)
    return {"message": "Async response"}

Test:

Sync: Each request waits its turn

Async: All requests run at the same time

That’s the power of non-blocking code.

🤔 Wait… Doesn’t `await` Still “Wait”?

Yes! But only your coroutine pauses — the event loop keeps going.

a = await some_async_call()
b = a + 1

Your function pauses at await, but the server is free to do other things.

When some_async_call() completes, your code resumes with b = a + 1.

🌀 What is a Coroutine?

A coroutine is a special type of function that can pause and resume its execution — perfect for handling I/O tasks like API calls, database queries, or sleep timers without blocking the main thread.

In Python, any function defined with async def is a coroutine:

async def get_data():
    await asyncio.sleep(1)
    return "Done"

Coroutines give you concurrency without threads — they’re lightweight, efficient, and ideal for high-performance web apps.

🧠 Final Thoughts

Use WSGI (sync) for simple apps or when working with older libraries.
Use ASGI (async) for modern apps that need speed, scale, or handle I/O (DBs, APIs).
Even a simple change like switching from time.sleep() to await asyncio.sleep() can unlock huge performance gains.

💬 TL;DR

Feature	Sync (WSGI)	Async (ASGI)
Blocking	Yes (per request)	No (per request)
Concurrency	Threads/Processes	Coroutines (cheap!)
Popular With	Flask, Django (classic)	FastAPI, Django (ASGI)
Performance	Good (low traffic)	Excellent (high traffic)

📚 References and Further Reading

Real Python: Async IO in Python
ASGI Spec: asgi.readthedocs.io
FastAPI Docs: fastapi.tiangolo.com
Django Async Support: docs.djangoproject.com
WSGI Spec: wsgi.readthedocs.io

Building a Decentralized Voting System with Smart Contracts

Joshua Hassan — Thu, 05 Sep 2024 11:08:55 +0000

What are Smart Contracts?
Smart Contracts in Voting
Building a Voting System with Smart Contracts
Key Variables in Our Voting Smart Contract
Key Functions of Our Voting Smart Contract
Benefits and Challenges
Resources to Learn More
Conclusion

What are Smart Contracts?

Imagine a vending machine. You put in money, press a button, and get your snack. No human needed to make this transaction happen. That's the basic idea behind a smart contract!

A smart contract is like a digital vending machine. It's a computer program that automatically executes actions when certain conditions are met. Here's what makes them special:

Automatic: They run by themselves once they're set up.
Trustless: You don't need to trust a middleman. The code ensures everything happens as agreed.
Transparent: Everyone can see the contract's code and how it works.
Secure: They're stored on a blockchain, making them very hard to hack or change.

In simple terms, smart contracts are "if-then" statements on a blockchain. If something happens, then a specific action is taken.

Smart Contracts in Voting

Now, let's think about how we could use a smart contract for voting. It could work like this:

Set up the election (like setting up our vending machine)
Register voters (like giving people the right coins for our machine)
Cast votes (like pressing buttons on the machine)
Count votes and declare results (like the machine dispensing the most-chosen snack)

All of this happens automatically, securely, and transparently. No one can stuff the ballot box or change votes without everyone noticing.

Building a Voting System with Smart Contracts

Let's look at how we might build a simple voting system using a smart contract. We'll use a language called Solidity, which is commonly used for writing smart contracts.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VotingDApp {
    // Contract code will go here
}

This is the shell of our contract. Now, let's fill it with some useful parts.

Key Variables in Our Voting Smart Contract

Let's break down the main variables used in our contract:

address public owner;
uint256 public pollCount;
mapping(uint256 => Poll) public polls;
mapping(address => bool) public registeredCandidates;
mapping(uint256 => mapping(address => Candidate)) public pollCandidates;
mapping(uint256 => address[]) public allCandidates;

Here's what each of these does:

owner: This stores the Ethereum address of the person who created the contract. They have special permissions.
pollCount: This keeps track of how many polls have been created. It's like a counter.
polls: This is a way to store all the polls. Each poll has a number (its ID), and this mapping links that number to all the poll's information.
registeredCandidates: This keeps track of which Ethereum addresses have registered as candidates.
pollCandidates: This is a bit more complex. It stores information about candidates for each poll. You can look up a candidate by the poll ID and the candidate's address.
allCandidates: This stores a list of all candidate addresses for each poll.

These variables help us keep track of all the information we need for our voting system.

Key Functions of Our Voting Smart Contract

1. Creating a Poll

function createPoll(string memory name, string memory imageUrl, uint256 startTime, uint256 endTime) public onlyOwner {
    require(startTime < endTime, "Invalid poll duration");

    pollCount++;
    Poll storage poll = polls[pollCount];
    poll.name = name;
    poll.imageUrl = imageUrl;
    poll.active = false;
    poll.startTime = startTime;
    poll.endTime = endTime;

    emit PollCreated(pollCount, name, imageUrl, startTime, endTime);
}

This function is like setting up a new election. Here's what it does:

Only the owner can create a poll (that's what onlyOwner means)
It checks that the end time is after the start time
It creates a new poll with a name, image, start time, and end time
It tells everyone a new poll has been created (that's what emit does)

2. Registering as a Candidate

function registerAsCandidate(uint256 pollId, string memory candidateName, string memory imageUrl) public pollExists(pollId) {
    require(pollCandidates[pollId][msg.sender].candidateAddress == address(0), "Already registered as a candidate");
    require(!isCandidateNameTaken(pollId, candidateName), "Candidate name already taken");

    pollCandidates[pollId][msg.sender] = Candidate({
        candidateAddress: msg.sender,
        name: candidateName,
        imageUrl: imageUrl,
        approved: false,
        votesReceived: 0
    });

    allCandidates[pollId].push(msg.sender);

    emit CandidateRegistered(pollId, msg.sender, candidateName, imageUrl);
}

This function lets someone sign up to be a candidate:

It checks that the poll exists and the person hasn't already registered
It makes sure the candidate name isn't already taken
It creates a new candidate with their name, image, and address
It tells everyone a new candidate has registered

3. Voting

function vote(uint256 pollId, address candidate) public {
    Poll storage poll = polls[pollId];
    require(poll.active, "Poll is not active");
    require(!poll.hasVoted[msg.sender], "Already voted");
    require(pollCandidates[pollId][candidate].approved, "Candidate not approved");

    poll.hasVoted[msg.sender] = true;
    poll.votes[candidate]++;
    poll.totalVotes++;
    pollCandidates[pollId][candidate].votesReceived++;

    if (poll.votes[candidate] > poll.highestVotes) {
        poll.highestVotes = poll.votes[candidate];
        poll.winner = candidate;
    }

    emit VoteCasted(pollId, msg.sender, candidate);
}

This is the actual voting function:

It checks that the poll is active and the voter hasn't already voted
It makes sure the candidate is approved
It records the vote and updates the vote count
If this candidate now has the most votes, it updates the winner
It tells everyone that a vote has been cast

4. Ending a Poll

function endPoll(uint256 pollId) public onlyOwner pollExists(pollId) {
    require(polls[pollId].active, "Poll is not active");

    polls[pollId].active = false;

    emit PollEnded(pollId, polls[pollId].winner);
}

This function ends a poll:

Only the owner can end a poll
It checks that the poll exists and is active
It marks the poll as inactive
It announces that the poll has ended and who the winner is

Benefits and Challenges

Benefits

Security: It's very hard to cheat or hack the system.
Transparency: Everyone can see how the voting works.
Automation: No need for manual counting or management.
Accessibility: People could potentially vote from anywhere.

Challenges

Technical Knowledge: It can be complicated for some people to use.
Cost: Running smart contracts on a blockchain can be expensive.
Scalability: It might be hard to handle very large elections.
Privacy: Balancing transparency with voter privacy can be tricky.

Resources to Learn More

If you're interested in learning more about smart contracts and blockchain technology, here are some great resources:

Ethereum.org's Introduction to Smart Contracts
Solidity Documentation
CryptoZombies - A fun, interactive way to learn Solidity
ConsenSys Academy - Offers courses on blockchain development
OpenZeppelin Learn - Tutorials and guides on smart contract development

Conclusion

Smart contracts offer an exciting new way to run voting systems. They can make voting more secure, transparent, and efficient. While there are challenges to overcome, the potential benefits make this an area worth exploring and developing further.

Remember, this is a simplified example. Real-world voting systems would need additional features and rigorous security measures. But hopefully, this gives you a good starting point for understanding how smart contracts can be used in voting!

You can find the full code for this voting system on GitHub: VotingDApp Smart Contract

Mastering Soft Delete

Joshua Hassan — Sun, 31 Dec 2023 16:25:41 +0000

Have you ever wondered what happens to that cute puppy picture you accidentally deleted from your phone? Vanished to digital oblivion? Not quite! There's a secret world in databases where deleted data isn't gone, it's just playing hide-and-seek. This magical trick is called soft delete, and it's a superhero for developers like you and me.

Imagine this: You're building a shopping app, and a customer accidentally removes their dream sneakers from their cart. Panic sets in, right? But not if you have soft delete! Instead of disappearing forever, those sneakers simply move to a special corner of the database, marked as "deleted" but still ready to be rescued. This gives you the chance to be the digital hero, swooping in to restore the order and save the day (and the customer's shopping spree).

Why is soft delete so awesome? Think of it as a safety net for your database:

Accidentally erased your grandma's recipe in your recipe app? No worries, soft delete brings it back with a snap.
Need to track who deleted what and when? Soft delete keeps an audit log, like a digital detective, making it easy to solve database mysteries.
Worried about deleting something connected to other things? Soft delete handles relationships like a pro, ensuring everything stays balanced and happy.

But hey, just like any power, soft delete needs training. Here's how you can wield it like a coding wizard in Django:

1. Building the Secret Hideout:

Create a special "SoftDeleteModel" that has a magic field called deleted_at. This field acts like a timer, marking the moment something went into hiding. Then, all your other models can inherit this power, making them soft-delete masters!

from django.db import models
from django.utils import timezone

class SoftDeleteManager(models.Manager):
    def with_deleted(self):
        return super().get_queryset().all()

class SoftDeleteModel(models.Model):
    deleted_at = models.DateTimeField(blank=True, null=True)

    objects = SoftDeleteManager()

    class Meta:
        abstract = True

    def soft_delete(self):
        self.deleted_at = timezone.now()
        self.save()

    def restore(self):
        self.deleted_at = None
        self.save()

class YourModel(SoftDeleteModel):
    # other fields go here

2. Finding the Hidden Treasures:

By default, only the living see the living. To see the ghosts in your database, you need to say the magic words: objects.with_deleted(). This reveals the hidden treasures, letting you see everything, even the deleted stuff.

# To retrieve deleted and non-deleted records
YourModel.objects.with_deleted().all()

# To retrieve only non-deleted records
YourModel.objects.all()

3. Bringing Back the Lost Souls:

Want to bring a deleted item back to life? Easy! Just set the deleted_at timer back to zero, and poof! It's back in the land of the living, ready to be used again.

instance = YourModel.objects.get(pk=1)
instance.restore()

Remember: Soft delete is a powerful tool, but with great power comes great responsibility. Make sure you have good reasons for keeping deleted things around, and don't let your database become a haunted house of forgotten data.

Now, go forth and conquer the world of soft delete! Remember, it's not just about saving data, it's about saving the day (and maybe preventing a few tears along the way). And who knows, maybe you'll even inspire other newbie developers to embrace the power of the disappearing act!

Bonus Tips for the Superheroes of Tomorrow:

Check out libraries like django-safedelete, django-soft-delete and django-paranoid for extra soft-delete superpowers.
Remember, even soft-deleted data takes up space, so have a plan for cleaning up the digital graveyard every now and then.
And most importantly, have fun and experiment! Soft delete is a playground for your coding creativity, so go wild and build amazing things!

Write Faster Django Queries

Joshua Hassan — Wed, 22 Feb 2023 15:17:07 +0000

Hi readers, I was recently working on a team project when I encountered inefficient and redundant code. To address this issue, I researched and experimented with various techniques for optimizing Django queries, which led to the creation of this article. Regardless of your experience level with Django, this article aims to equip you with the necessary tools to enhance the performance of your applications.

TABLE OF CONTENTS

Introduction
Prerequisites
What is Django ORM
How to view database performance
The N+1 problem
Ways to write faster and more efficient queries
- Use select_related() and prefetch_related():
- Use filter() instead of get()
- Use only() or defer()
- Use subqueries
- Use Q objects for complex queries
- Use annotations
- Use aggregation
- Use caching
- Honorable mentions
Conclusion
References

Introduction

Developers prioritize building web applications that are efficient and scalable, and optimizing database queries is crucial to achieving these goals. Django's built-in Object-Relational Mapping (ORM) allows developers to interact with the database without writing complex SQL queries. However, poorly optimized queries can result in slow performance and increased server load. In this article, we'll discuss techniques for writing faster Django queries and improving your application's overall performance.

At the end of the article, readers will have gained a better understanding of how to write optimized queries, and will be able to implement these techniques in their own applications. Additionally, readers will have gained a deeper understanding of how the Django ORM works, and will be able to use this knowledge to make informed decisions when working with databases in their projects.

Prerequisites

Knowledge of Python
Basic Knowledge of Django
Basic Knowledge of Django-Orm

What is Django ORM

The Django web framework provides a built-in tool called Object-Relational Mapping (ORM), which enables developers to interact with relational databases using high-level Python objects instead of writing complex SQL queries. The ORM maps database tables to Python classes, and database rows to instances of those classes, providing a simple and intuitive way to perform CRUD (create, read, update, and delete) operations on the database. This abstraction layer simplifies working with databases, removes the need to deal with low-level details, and reduces the risk of SQL injection attacks. Moreover, the Django ORM is compatible with a variety of databases, such as PostgreSQL, MySQL, SQLite, and Oracle.

How to view database performance

You can use the Django Debug Toolbar to view DB performance. The below link is for Django Debug Toolbar documentation:

https://django-debug-toolbar.readthedocs.io/en/latest/installation.html
Use QuerySet.explain() to understand how specific QuerySets are executed by your database.
Use django silk to view DB performance. https://github.com/jazzband/django-silk

But in this guide, we will be using the first option

The N+1 problem

The N+1 problem is a common issue that can occur in ORM frameworks, including Django. It arises when you fetch a collection of objects and then iterate over them to access a related object. This can lead to N+1 database queries being executed, where N is the number of objects you're iterating over.

For example, suppose you have a Book model with an author ForeignKey field, and you want to display a list of books with their author names. If you retrieve a queryset of all books and iterate over them to access the author names, Django will execute a separate database query for each book to retrieve its associated author. This can lead to a significant number of database queries being executed, which can slow down your application.

Ways to write faster and more efficient queries

1. Use select_related() and prefetch_related():

These methods are used to optimize database queries by reducing the number of database queries. select_related() is used to retrieve related objects in one database query, while prefetch_related() is used to retrieve multiple sets of related objects in one database query.

Suppose you have two models, Author and Book, where each book has an author

from  django.db  import  models

class  Author(models.Model):
    name  =  models.CharField(max_length=100)

    def  __str__(self):
        return  self.name

    class  Meta:
        verbose_name  =  'author'
        verbose_name_plural  =  'authors'


class  Book(models.Model):
    title  =  models.CharField(max_length=100)
    author  =  models.ForeignKey(Author, on_delete=models.CASCADE)

    def  __str__(self):
        return  self.title

    class  Meta:
        verbose_name  =  'book'
        verbose_name_plural  =  'books'

Here are three versions of a view that retrieves a list of books and their authors using the Django ORM. The first version is a simple implementation that retrieves the data using two separate queries, the second version optimizes the queries using select_related() and the third version optimizes the queries using prefetch_related():

# Version 1 - Simple implementation
def book_list(request):
    books = Book.objects.all()
    context = {'books': books}
    return render(request, 'book_list.html', context)

# Version 2 - Optimized implementation using select_related()
def book_list(request):
    books = Book.objects.select_related('author').all()
    context = {'books': books}
    return render(request, 'book_list.html', context)

# Version 3 - Optimized implementation using prefetch_related()
def book_list(request):
    books = Book.objects.prefetch_related('author').all()
    return render(request, 'book_list.html', {'books': books})

booklist.html

{% for  book  in  books %}
<div  class="w-1/2 px-4 mb-8">
    <div  class="bg-white shadow-lg rounded-lg overflow-hidden">
        <div  class="p-4">
            <h2  class="text-lg font-bold">{{ book.title }}</h2>
            <p  class="text-gray-700">{{ book.author }}</p>
            <p  class="text-gray-700 mt-2">{{ book.description }}</p>
        </div>
    </div>
</div>

{% endfor %}

In the first version, the books are retrieved using a single query (Book.objects.all()), but a separate query is executed for each author (book.author in the for loop). This can lead to the N+1 query problem if there are many books and authors in the database, as it will result in a large number of queries being executed.

we are having 6 queries

The second version of the view is optimized because it reduces the number of queries that need to be executed. The select_related() method is used to retrieve the related author objects in the same query as the books, using a join operation. This means that only one query is executed, regardless of the number of books and authors in the database. By reducing the number of queries, the second version of the view is more optimized than the first version.

reduced to 1 query

The third version of the view is also optimized, but it uses a different technique called prefetch_related(). This method is useful when you want to retrieve related objects that are not directly related to the main object being queried (in this case, Book). In the Book and Author model, there is a foreign key relationship between the two models, and select_related() works perfectly to optimize the query. However, if the Author model had a foreign key relationship with another model, say Publisher, and you wanted to retrieve all the books written by authors and the publisher information for each book, select_related() would not work in this case because it only works with directly related models.

In such cases, you can use prefetch_related() to retrieve the related objects in a separate query. In the third version of the view, prefetch_related('author') is used to retrieve all the authors for the books in a single query. This technique is particularly useful when you have many related objects and need to optimize the queries while minimizing the number of database hits.

By using prefetch_related() in the third version of the view, Django retrieves all the related author objects in a single query and caches them for use in the template. This results in faster query execution times and reduces the number of database hits, especially when dealing with large datasets.

optimized to 2 queries

2. Use filter() instead of get():

When retrieving a single object from the database using the Django ORM, you have two options: get() or filter(). Both methods are used to retrieve an object based on a set of conditions, but they behave differently.

get() retrieves a single object that matches the specified conditions, or raises an exception if no object is found or more than one object is found. For example, to retrieve a user with a specific email address, you can use the following code:

from django.contrib.auth.models import User

user = User.objects.get(email='user@example.com')

On the other hand, filter() retrieves a QuerySet of objects that match the specified conditions. For example, to retrieve all users with a specific first name, you can use the following code:

users = User.objects.filter(first_name='John')

When you use get() to retrieve a single object, Django makes a single database query to retrieve the object. However, if the specified conditions match more than one object, get() raises a MultipleObjectsReturned exception. If no object is found, get() raises a DoesNotExist exception.

When you use filter() to retrieve a single object, Django still makes two database queries: one to retrieve the matching objects, and another to retrieve the first object from the matching objects. However, you can avoid making the second query by using the first() method to retrieve the first object from the QuerySet. For example:

user = User.objects.filter(email='user@example.com').first()

This code retrieves the first user that matches the email address, or returns None if no matching user is found.

In summary, using filter() instead of get() when retrieving a single object can reduce the number of database queries by avoiding exceptions and allowing you to retrieve the first object from a QuerySet instead of making a separate query.

3. Use only() or defer():

When querying a model, Django retrieves all fields of that model by default. However, in many cases, you may not need all fields for a particular query. This can lead to unnecessary database queries, which can impact performance.

Using the only() method, you can specify the fields you need for a particular query, which will limit the amount of data retrieved from the database. This can help reduce the number of queries and minimize the amount of data transferred over the network, which can improve the overall performance of your application.

Similarly, using the defer() method, you can exclude fields that are not needed for a particular query. This can be especially useful for fields that contain large amounts of data, such as binary data or large text fields. Excluding these fields from the query can help reduce the amount of data transferred over the network and improve the performance of your application.

Suppose you have a model User with many fields, but you only need to retrieve the username and email fields. You can use the only() method to limit the fields returned by the query:

users = User.objects.only('username', 'email').all()

This will retrieve all users with only their username and email fields in a single query, instead of retrieving all fields for each user.

Alternatively, suppose you have a model User with many fields, but you don't need to retrieve the password field. You can use the defer() method to exclude the password field from the query:

users = User.objects.defer('password').all()

This will retrieve all users with all fields except the password field in a single query.

Overall, using only() and defer() can be a powerful technique for optimizing your Django application's performance by reducing the amount of data retrieved from the database and minimizing the number of queries executed.

4. Use subqueries

Subqueries can be used to retrieve related data in a more efficient way. For example, if you need to retrieve the count of related objects for each object in a queryset, you can use a subquery instead of using a loop.

Suppose you have two models, Author and Book, where each book has an author. If you want to retrieve a list of authors with the count of their books, you could use a loop to iterate through each author and count their books. However, this approach would result in multiple database queries and slow performance for large datasets. Instead, you can use a subquery to retrieve the count of books for each author in a single query.

Here's an example of the inefficient solution using a loop:

def  number_of_author_books(request):
    authors  =  Author.objects.all()
    for  author  in  authors:
        count  =  Book.objects.filter(author=author).count()
        author.count =  count

    return  render(request, "author_books.html", {'authors': authors})

In this example, the loop iterates through each author and retrieves the count of books using a separate database query for each author. This can result in slow performance, especially for large datasets.

We have 3 queries

Now, here's an example of the optimized solution using a subquery:

from django.db.models import OuterRef, Subquery, Count

def  number_of_author_books_optimized(request):
    authors  =  Author.objects.annotate(
    book_count=Subquery(
        Book.objects.filter(author=OuterRef('pk')).values('author').annotate(
            count=Count('id')
            ).values('count')[:1]
        )
    )

    return  render(request, "author_books.html", {'authors': authors})

In this example, the annotate() method is used to add a book_count field to each author. The resulting authors queryset is passed to the author_books.html template, which displays the author's name and the number of books they've written in a table.
The Subquery function is used to retrieve the count of books for each author in a subquery, which is more efficient than using a loop. The OuterRef function is used to reference the pk of the outer query (i.e., the Author queryset), and the [:1] slice is used to limit the subquery to return only the first value.

We now optimized to have 1 query

here is the html

{% extends 'base.html' %}

{% block content %}
<div class="max-w-7xl mx-auto py-6 sm:px-6 lg:px-8">
    <div class="bg-white overflow-hidden shadow-xl sm:rounded-lg">
        <table class="min-w-full divide-y divide-gray-200">
            <thead class="bg-gray-50">
                <tr>
                    <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                        Author
                    </th>
                    <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
                        Number of Books
                    </th>
                </tr>
            </thead>
            <tbody class="bg-white divide-y divide-gray-200">
                {% for author in authors %}
                <tr>
                    <td class="px-6 py-4 whitespace-nowrap">
                        <div class="text-sm font-medium text-gray-900">{{ author.name }}</div>
                    </td>
                    <td class="px-6 py-4 whitespace-nowrap">
                        <div class="text-sm font-medium text-gray-900">{{ author.count }}</div>
                        <div class="text-sm font-medium text-gray-900">{{ author.book_count  }}</div>
                    </td>
                </tr>
                {% endfor %}
            </tbody>
        </table>
    </div>
</div>
{% endblock %}

By using a subquery, we can retrieve the count of books for each author in a single database query, resulting in much faster performance compared to using a loop.

Subqueries can be a highly effective method for fetching related data in a more efficient manner, particularly for complex or large datasets. Nevertheless, it is crucial to exercise caution while using subqueries and to evaluate their performance for your particular use case.

5. Use Q objects for complex queries:

Q objects allow you to create complex queries with multiple conditions. They are especially useful when combining multiple conditions with OR or NOT operators.

Here is an example of an inefficient query that uses multiple filter conditions:

books = Book.objects.filter(
    author__name='John',
    publisher__name='Penguin',
).exclude(
    genre='Romance'
)

This query retrieves all books written by an author named John, published by Penguin, and excludes any books with the genre 'Romance'. However, this can get messy and hard to read when dealing with many conditions.

Using Q objects, we can simplify this query by combining multiple conditions using OR or NOT operators:

from django.db.models import Q

books = Book.objects.filter(
    Q(author__name='John') |
    Q(publisher__name='Penguin')
).exclude(
    Q(genre='Romance') & Q(publisher__name='Penguin')
)

This query retrieves all books written by an author named John or published by Penguin, and excludes any books with the genre 'Romance' and published by Penguin.

By using Q objects, we can write more concise and readable queries, while also improving query performance by reducing the number of database hits.

It's important to note that using too many Q objects or nesting them too deeply can also have a negative impact on performance. It's important to strike a balance between readability and efficiency when using Q objects.

Here is an example of a nested Q object that could potentially be inefficient:

books = Book.objects.filter(
    Q(author__name='John') |
    Q(
        Q(publisher__name='Penguin') &
        Q(genre='Mystery')
    )
)

In this query, we are retrieving all books written by an author named John or published by Penguin with the genre 'Mystery'. However, this query could potentially be slow if the database has to perform many nested queries to retrieve the results. In cases like this, it may be better to break the query into multiple simpler queries instead.

6. Use annotations:

In Django, annotations offer a way to supplement the queryset with additional information that isn't stored in the database. Annotations come in handy when you need to compute aggregate values or perform computations on associated objects. Employing annotations enables you to sidestep executing multiple queries, thus enhancing your application's efficiency.

To illustrate, consider a scenario where you have a Product model and your aim is to fetch the total count of reviews for each product. One inefficient approach would be to employ a loop to iterate through each product and retrieve the review count for each one.

products = Product.objects.all()
for product in products:
    reviews = product.reviews.all()
    product.num_reviews = len(reviews)
return render(request, "product_list.html", {"products": products})

This approach will result in an N+1 query problem, where N is the number of products in the queryset. A more efficient way to do this is to use the annotate() method to add an extra field to the queryset:

from django.db.models import Count

products = Product.objects.annotate(num_reviews=Count('reviews'))
return render(request, "product_list.html", {"products": products})

Here, we are using the Count() aggregation function to count the number of related reviews for each product. The num_reviews field is added to the queryset as an annotation, and we can access it in the template.

Using annotations can greatly improve the performance of your queries by reducing the number of database queries required. However, you should be careful when using them with large datasets, as they can increase the memory usage of your application. It's always a good practice to test the performance of your queries with realistic data and adjust them as necessary.

7. Use aggregation:

Aggregation is a powerful feature in Django that allows you to perform complex calculations on a set of values in the database. By using aggregation, you can minimize the number of queries needed to retrieve and process data, which can significantly improve performance.

For example, let's say you have a model Order with a field price, and you want to calculate the total revenue for all orders. You can use the aggregate() method to perform this calculation in a single query:

from django.db.models import Sum

total_revenue = Order.objects.aggregate(total=Sum('price'))['total']

In this example, the aggregate() method calculates the sum of the price field for all Order objects, and returns the result as a dictionary with the key 'total'. This code is much more efficient than manually iterating over all Order objects and summing their prices, especially if there are a large number of orders in the database.

Another example is calculating the average rating for a set of Product objects. Here is the inefficient version that requires multiple queries:

products = Product.objects.all()
ratings_sum = 0
count = 0
for product in products:
    ratings = Rating.objects.filter(product=product)
    ratings_sum += sum(rating.value for rating in ratings)
    count += ratings.count()
average_rating = ratings_sum / count if count > 0 else 0

This code iterates over all Product objects, and for each product, it queries the related Rating objects and calculates the sum and count of their values. Finally, it calculates the average rating by dividing the sum by the count. This approach requires multiple queries and can be very slow if there are a large number of products and ratings.

Here is the optimized version using aggregation:

from django.db.models import Avg

average_rating = Product.objects.annotate(avg_rating=Avg('ratings__value')).aggregate(avg=Avg('avg_rating'))['avg']

In this code, we use the annotate() method to add an avg_rating field to each Product object, which is the average of the value field of all related Rating objects. Then, we use the aggregate() method to calculate the average of the avg_rating field for all Product objects. This code only requires a single query and is much faster than the previous version.

8. Use caching:

Caching allows you to store the results of a query in memory or on disk, so that subsequent requests can be served from the cache instead of making a database query. This can significantly improve the performance of your application.

It is a powerful tool for query optimization as it allows you to avoid executing the same query repeatedly by storing the results in memory or on disk. By caching the results of a query, subsequent requests can be served faster without hitting the database, which can significantly improve the performance of your application.

Here's an example of how caching can be used to improve query performance. Suppose you have a view that displays a list of products with their corresponding categories:

from django.shortcuts import render
from .models import Product

def product_list(request):
    products = Product.objects.all()
    categories = set(p.category for p in products)
    context = {
        'products': products,
        'categories': categories,
    }
    return render(request, 'product_list.html', context)

This view retrieves all products from the database and then loops through them to extract the set of categories. This can be inefficient if you have a large number of products.

To optimize this query using caching, you can use Django's caching framework to store the set of categories in cache. Here's the updated view:

from django.shortcuts import render
from django.core.cache import cache
from .models import Product

def product_list(request):
    products = Product.objects.all()
    categories = cache.get('categories')
    if categories is None:
        categories = set(p.category for p in products)
        cache.set('categories', categories)
    context = {
        'products': products,
        'categories': categories,
    }
    return render(request, 'product_list.html', context)

In this updated view, the categories are first retrieved from the cache using the cache.get() function. If they are not found in the cache, they are computed and stored in cache using the cache.set() function. Subsequent requests for the same view will retrieve the categories from cache instead of recomputing them.

Note that caching can also have drawbacks, such as increased memory usage and the need to keep the cache in sync with the database. It's important to use caching judiciously and only when it provides a measurable improvement in performance.

Some pros of using caching include

Faster response times: Caching can reduce the response times of web pages by storing frequently accessed data in memory or on disk, reducing the need to generate data from scratch each time a request is made.
Scalability: Caching can help improve the scalability of web applications by reducing the load on the database and web server.
Reduced network traffic: By caching frequently accessed data, you can reduce the amount of data that needs to be transmitted over the network, resulting in faster load times.
Customizable caching policies: Django cache allows you to configure different caching policies for different types of data, giving you fine-grained control over how and when data is cached.

Cons of using caching include

Increased complexity: Adding caching to an application adds complexity, which can make it harder to maintain and debug.
Increased memory usage: Depending on the caching policy used, caching can result in increased memory usage, which can impact the performance of other applications running on the same server.
Cache invalidation: Caching introduces the problem of cache invalidation, which is the process of keeping the cache up-to-date with changes in the underlying data. In some cases, it may be difficult to ensure that the cache is always up-to-date, which can lead to inconsistent data being displayed to users.
Security risks: Caching sensitive data can introduce security risks if the cache is not properly secured.

Overall, caching can be an effective way to improve the performance of web applications, but it should be used judiciously and with care. It's important to weigh the potential benefits against the costs and risks before deciding to use caching in a production environment.

For more information on how to set this up, there is a link to the official django docs in the reference section

9. Use indexing:

Indexing can improve the performance of your database queries by allowing the database to retrieve data more quickly. You can add indexes to your database tables using Django's migration framework.

10. Use database-level query optimization techniques:

Depending on the database you are using, there may be specific query optimization techniques you can use to improve performance, such as optimizing the database schema, tuning database parameters, or using a different database engine.

11. Use third-party libraries:

There are many third-party libraries available for Django that can help you optimize your database queries. For example, the django-debug-toolbar can be used to analyze the performance of your queries and identify areas for improvement.

Conclusion

In conclusion, writing faster queries is an essential part of optimizing a Django application's performance. This article highlights several best practices for writing efficient queries, such as using the select_related() and prefetch_related() methods, limiting the number of fields returned, and avoiding unnecessary database hits. The use of third-party packages like Django Debug Toolbar and Django Silk can also provide insight into query performance and help identify potential areas for optimization. By following these guidelines and regularly monitoring query performance, developers can ensure that their Django applications are performing as efficiently as possible.

Resources

JS vs TS: A Comprehensive Guide to Choosing the Right Programming Language

Joshua Hassan — Sun, 29 Jan 2023 21:32:01 +0000

In the world of web development, JavaScript and TypeScript are two of the most commonly used programming languages for creating dynamic web pages and web applications. JavaScript has a long-standing reputation among web developers, whereas TypeScript is a more recent addition to the scene that has gained popularity in recent years.

Choosing the right language can be a difficult choice for developers due to the differences and similarities between the two. This article will delve into these differences, exploring topics such as type checking, classes, namespaces, and ES6 features. This article aims to give a comprehensive understanding of both JavaScript and TypeScript, allowing you to make an informed decision about which language is best for your project.

What is JavaScript?

JavaScript, a widely utilized programming language, is renowned for its ability to create dynamic web pages and web applications. It was invented in the mid-1990s by Brendan Eich, while he was employed at Netscape Communications Corporation. JavaScript operates on the client-side, running in the user's browser rather than on the server, making it a crucial component in the development of interactive websites and applications.

JavaScript is a versatile, object-oriented programming language used to build dynamic web pages and applications. It is a client-side language that executes in the user's browser and is capable of working with asynchronous code, making it well-suited for modern web development. JavaScript is loosely typed, meaning the data type of a variable can change during runtime, and it enables the creation of complex data structures. The language is supported by all major browsers, such as Chrome, Firefox, Edge, and Safari, and has widespread usage in front-end and server-side scripting through Node.js. With millions of developers relying on it, JavaScript is considered an essential tool in the world of web development.

What is TypeScript?

TypeScript is an object-oriented language that is statically typed, maintained by Microsoft, and compiled. It is a superset of JavaScript that strictly adheres to its syntax and adds additional features like optional type annotations, classes, interfaces, namespaces, and modules. This makes TypeScript a more efficient choice for complex, large-scale projects, compared to its dynamic and interpreted predecessor.

TypeScript also includes features such as static typing, which helps to catch type-related errors at compile time rather than at runtime, and improved support for object-oriented programming, which makes it easier to write clean, maintainable, and scalable code.

TypeScript compiles to JavaScript, which means that it can be executed in any environment that supports JavaScript, such as a browser or a server. As a result, TypeScript has become a popular choice for building complex web applications and large-scale software systems, and it is supported by many popular libraries and frameworks, such as Angular, React, and Vue.js.

JavaScript vs TypeScript

JavaScript (JS) and TypeScript (TS) are both programming languages used for web development, but they have some key differences:

1. Type Checking:

Type checking is a process of verifying the type of a variable or an expression at runtime to ensure that it meets the expected type. Type checking is important because it can help to catch type-related errors before they cause unexpected behavior in your code.

In JavaScript, type verification is done dynamically, allowing for variables to change their type during runtime. For example:

let x = 42;
x = "Hello";

In this example, the variable x is initially assigned the value 42, which is a number. However, it is then reassigned the value "Hello", which is a string. This is possible in JavaScript because it is a dynamically typed language, and the type of a variable can change dynamically during runtime.

On the other hand, TypeScript has static type checking, which means that the type of a variable must be specified at compile time and cannot change dynamically during runtime. For example:

let x: number = 42;
x = "Hello"; // Type '"Hello"' is not assignable to type 'number'.

2. ES6 Features:

ECMAScript 6 (ES6), also known as ECMAScript 2015, is a version of JavaScript that introduced several new features and syntax improvements. These features are designed to make JavaScript more expressive, readable, and maintainable, and have been widely adopted by developers.

Both JavaScript and TypeScript support most of the ES6 features, including:

Arrow functions: A shorthand syntax for writing anonymous functions.
Template literals: A way to embed expressions into strings using the backtick (`) character.
Destructuring: A way to extract data from arrays and objects into separate variables.
Modules: A way to organize code into reusable and manageable pieces.
Classes: A way to define object-oriented classes in JavaScript.
Promises: A way to handle asynchronous code and error handling.

However, TypeScript provides additional features and syntax that are not available in JavaScript, including:

Type annotations: A way to specify the type of a variable, function, or expression.
Interfaces: A way to define a blueprint for an object.
Generics: A way to write reusable functions and classes that can work with any type.
Decorators: A way to add metadata to a class, method, or property.

Both JavaScript and TypeScript support most of the ES6 features, but TypeScript provides additional features and syntax that are not available in JavaScript, making it a more powerful and expressive language for building large and complex applications.

3. Classes:

Classes are a fundamental concept in object-oriented programming (OOP) that provide a blueprint for creating objects and encapsulating data and behavior.

JavaScript has a prototype-based model for creating objects, and it does not have a built-in class syntax. However, classes can be simulated in JavaScript using prototypes and functions. For example:

function Person(firstName, lastName) {
  this.firstName = firstName;
  this.lastName = lastName;
}

Person.prototype.getFullName = function() {
  return this.firstName + " " + this.lastName;
};

let person = new Person("John", "Doe");
console.log(person.getFullName()); // "John Doe"

In this example, the Person function acts as a constructor for creating objects, and the getFullName method is added to the prototype of the Person function.

On the other hand, TypeScript has a class syntax that provides a more familiar and convenient way of defining objects and encapsulating data and behavior. For example:

class Person {
  firstName: string;
  lastName: string;

  constructor(firstName: string, lastName: string) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  getFullName() {
    return this.firstName + " " + this.lastName;
  }
}

let person = new Person("John", "Doe");
console.log(person.getFullName()); // "John Doe"

In this example, the Person class is defined using the class syntax, and it has a constructor and a method. The class syntax provides a more intuitive and familiar way of defining objects and encapsulating data and behavior compared to the prototype-based model in JavaScript.

In conclusion, TypeScript provides a class syntax that provides a more intuitive and convenient way of defining objects and encapsulating data and behavior compared to the prototype-based model in JavaScript.

4. Namespaces:

Namespaces are a way of organizing and grouping related code together. TypeScript supports namespaces, which are used to organize code into logical groups and prevent naming collisions, whereas in JavaScript you have to use modules for this purpose. In JavaScript, namespaces can be achieved by using objects and nested objects. For example:

let MyNamespace = {};

MyNamespace.Utils = {
  sum: function(a, b) {
    return a + b;
  },
  subtract: function(a, b) {
    return a - b;
  },
};

console.log(MyNamespace.Utils.sum(1, 2)); // 3

In this example, the MyNamespace object acts as a namespace, and the Utils object contains the related utility functions.

On the other hand, TypeScript provides a namespace keyword that provides a more intuitive and convenient way of organizing and grouping related code together. For example:

namespace MyNamespace {
  export function sum(a: number, b: number): number {
    return a + b;
  }

  export function subtract(a: number, b: number): number {
    return a - b;
  }
}

console.log(MyNamespace.sum(1, 2)); // 3

In this example, the MyNamespace namespace is defined using the namespace keyword, and the related functions are exported using the export keyword. The namespace keyword provides a more intuitive and convenient way of organizing and grouping related code together compared to using objects in JavaScript.

In conclusion, TypeScript provides the namespace keyword that provides a more intuitive and convenient way of organizing and grouping related code together compared to using objects in JavaScript.

5. Compilation:

The process of transforming a high-level programming language into machine-readable code is called Compilation. Unlike TypeScript, which is a statically typed language and requires the use of a compiler, JavaScript is dynamically typed and does not need to be compiled before it is executed. This means that JavaScript code can be written and tested on the fly, making it ideal for rapid prototyping.

On the other hand, TypeScript's static typing allows the compiler to catch type-related errors before execution, leading to a more efficient and error-free development process. The TypeScript code is written and then compiled into JavaScript, which can then be executed by the browser or Node.js runtime. This ensures that the generated JavaScript code is of high quality and free from type-related errors.

The following is an example of TypeScript code:

function greet(name: string) {
  return `Hello, ${name}!`;
}

const message = greet("John");
console.log(message); // "Hello, John!"

And this is the equivalent JavaScript code generated by the TypeScript compiler:

function greet(name) {
  return "Hello, " + name + "!";
}

var message = greet("John");
console.log(message); // "Hello, John!"

In conclusion, TypeScript requires compilation, which allows the TypeScript compiler to perform type-checking and catch type-related errors before the code is executed. This makes the development process more efficient and less error-prone compared to JavaScript, which is executed directly without the need for compilation.

6. Type Annotations:

Type annotations in programming languages specify the expected type of a variable or expression.

In JavaScript, there is no built-in syntax for type annotations, and type information is not available at compile time. For example:

let x = 42;

In this example, the type of the variable x is inferred to be a number by the value that it is assigned. However, there is no explicit type information available in the code.

On the other hand, TypeScript provides optional type annotations, which allow developers to specify the expected type of a variable or expression explicitly. For example:

let x: number = 42;

In this example, the type of the variable x is explicitly specified as a number using the colon : syntax. This information is available at compile time, and TypeScript can use it to perform static type checking, catch type-related errors, and provide better tooling and code analysis.

TypeScript type annotations are optional, but they are highly recommended for large-scale applications because they can improve the quality and maintainability of the code. The type annotations can be inferred from the values that are assigned to the variables, or they can be specified explicitly by the developer.

In conclusion, TypeScript provides optional type annotations, which can improve the quality, maintainability, and safety of the code, while JavaScript does not have built-in syntax for type annotations.

In summary, TypeScript adds optional static typing, classes, and other features to JavaScript, making it a more suitable choice for larger and more complex projects, while JavaScript is still widely used due to its ease of use and compatibility with older browsers.

What is API Latency

Joshua Hassan — Sat, 31 Dec 2022 21:49:32 +0000

What is API latency?

Latency in an API refers to the time it takes for a user's query to be processed and for a response to be returned. A lower latency means a faster response time and a better user experience.

What is the response rate?

Response rate measures the total time it takes for a server to fulfill a request, including the API latency, or the time it takes for information to be transmitted from the server to the requesting party. It is important to optimize response rate to improve the overall user experience. Latency is a component of response rate but is not the only factor that contributes to the response time measurement.

What is server response time?

Response time refers to the amount of time it takes for the server to process a request and send back a response to the client. A shorter response time can lead to a better user experience and can be a key factor in the performance and efficiency of an API. It is important to monitor and optimize server response time to ensure that the API is functioning effectively and efficiently.

What is a good server response time?

Typically anything less than 300ms would put you in the best 20% of sites, and less than 200ms would put you in the best 10%
source

What is a bad server response time?

Server response time of more than 830ms would put you in the worst 20% of sites, and more than 1.1 seconds would put you in the worst-performing sites.
source

Overview of APIs latency rate vs response rate

The time it takes for a request to be fulfilled by an API server, including the time it takes for the requested information to be transmitted, is known as the response rate. The API latency rate refers specifically to the time it takes for the requested information to be transmitted from the server to the requesting party.

What causes high latency?

The speed at which a server responds to a request for information through an API can be affected by a variety of factors, such as the server's capacity and processing power, the number of requests being made at a given time, and the efficiency with which those requests are managed. High latency rates, or slow response times, can negatively impact user satisfaction and may be caused by server overload, a bottleneck of requests, or other issues.

How can the latency of an API be monitored?

There are various methods for monitoring the latency of an API, such as a ping test or using web service HTTP/HTTPS monitors. These tools can provide information about API latency, response times, loading times, and other relevant metrics to help understand the user experience.

Some ways to reduce latency

These include optimizing server hardware and capacity, using efficient algorithms and data structures, minimizing the distance between the server and the requesting party, and minimizing the amount of data sent over the network.

Integrating Paystack payments in Django website

Joshua Hassan — Fri, 21 Oct 2022 20:57:11 +0000

TABLE OF CONTENTS

Introduction
Prerequisites
Project Setup
Creating models
User registration and login
Implementing deposit view
Conclusion
Reference

Introduction

Paystack is a payment gateway that helps individuals and businesses in Africa to accept payments from anywhere in the world. In this guide, I will be showing you how to use Paystack as a third-party API to facilitate payments in your Django website.

Prerequisites

To follow through with this guide you will need:

A good understanding of Python
Basic understanding of Django
Basic understanding of Html
Usage of the Python request library
A Paystack account

Now, let's dive into the guide, all codes can be found on Github in this repository.

Project Setup

Create a folder, start a virtual environment and start basic project
create a virtual environment using virtualenv env
activate the virtual environment using source env/Scripts/activate
install django using pip install django this will install the latest version of django, however I am going to use version 3.0 in this guide, to install that do pip install django==3.0

Create a project and install apps
Now start the project using django-admin startproject zcore .
zcore is the name of the project and dot is used to start the project in the current directory.
Next step is two create two apps, one for authentication and another to handle all payments related code

python manage.py startapp accounts
python manage.py startapp payments

Add the newly installed apps in settings.py
Also add paystack secret and public keys in settings.py



PAYSTACK_SECRET_KEY = ""
PAYSTACK_PUBLIC_KEY = ""

where to find them on paystack

Navigate into both folders created and add a new file called urls.py and add the following code



from django.urls import path

urlpatterns = [

]

Include these urls in main url file zcore.urls
Your file should look like this



from  django.contrib  import  admin
from  django.urls  import  path, include

urlpatterns  = [
path('admin/', admin.site.urls),
path('accounts/', include("accounts.urls")),
path('payments/', include("payments.urls")),
]

Creating models

Next step is to create a wallet model to keep track of funds deposited by a user and a payment model to describe what a payment is.
In payments.model



from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
import secrets
from .paystack  import  Paystack

# Create your models here.
class UserWallet(models.Model):
    user = models.OneToOneField(User, null=True, on_delete=models.CASCADE)
    currency = models.CharField(max_length=50, default='NGN')
    created_at = models.DateTimeField(default=timezone.now, null=True)

    def __str__(self):
        return self.user.__str__()

class Payment(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True)
    amount = models.PositiveIntegerField()
    ref = models.CharField(max_length=200)
    email = models.EmailField()
    verified = models.BooleanField(default=False)
    date_created = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ('-date_created',)

    def __str__(self):
        return f"Payment: {self.amount}"

    def save(self, *args, **kwargs):
        while not self.ref:
            ref = secrets.token_urlsafe(50)
            object_with_similar_ref = Payment.objects.filter(ref=ref)
            if not object_with_similar_ref:
                self.ref = ref

        super().save(*args, **kwargs)

We will need another helper class to handle payment verification, so in the payments folder create a file called paystack.py
paste this block of code in the file



from django.conf import settings
import requests

class Paystack:
    PAYSTACK_SK = settings.PAYSTACK_SECRET_KEY
    base_url = "https://api.paystack.co/"

    def verify_payment(self, ref, *args, **kwargs):
        path = f'transaction/verify/{ref}'
        headers = {
            "Authorization": f"Bearer {self.PAYSTACK_SK}",
            "Content-Type": "application/json",
        }
        url = self.base_url + path
        response = requests.get(url, headers=headers)

        if response.status_code == 200:
            response_data = response.json()
            return response_data['status'], response_data['data']

        response_data = response.json()

        return response_data['status'], response_data['message']

you will need to install requests for this so do a quick pip install requests
with that we can now add a verify payment property on our payment model



def amount_value(self):
        return int(self.amount) * 100

def verify_payment(self):
    paystack = Paystack()
    status, result = paystack.verify_payment(self.ref, self.amount)
    if status:
        if result['amount'] / 100 == self.amount:
            self.verified = True
        self.save()
    if self.verified:
        return True
    return False

User registration and login

For the registration and login, I will be doing something very simple as it is not the focus of this guide.
Paste the code in accounts.views



from django.shortcuts import render, redirect
from django.contrib.auth.models import User
from payments.models import UserWallet
from django.contrib.auth import login, logout, authenticate
from django.contrib.auth.decorators import login_required

# Create your views here.
def register(request):
    if request.method == "POST":
        username = request.POST['username']
        password = request.POST['password']
        user = User.objects.create(username=username, password=password)
        UserWallet.objects.create(user=user)
    return render(request, "register.html")

def login_view(request):    
    if request.method == "POST":
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(username=username, password=password)
        if user is not None:
            login(request, user)
                    return redirect('initiate_payment')
        else:
            return redirect('login')

    return render(request, 'login.html')

@login_required(login_url="login")
def logout_view(request):
    logout(request)
    return redirect('login')

Add the corresponding url paths for the views in urls.py



from  django.urls  import  path
from . import views

urlpatterns = [
    path('register/', views.register, name="register"),
    path('login/', views.login_view, name="login"),
    path('logout/', views.logout_view, name="logout"),
]

We will use dummy login and register page from bootstrap, file can be found in the github repo .

Setup templates dirs by adding 'DIRS': [os.path.join(BASE_DIR, 'templates')] in settings.py

At this point you can run python manage.py runserver and navigate to 127.0.0.1:8000/accounts/register in your browser window to see the registration page.

You will see some warnings, to get rid of them makemigrations and migrate using;

python manage.py makemigrations 
python manage.py migrate

Create a superuser so that we can login to django admin via 127.0.0.1:8000/admin to see all the magic happening.

python manage.py createsuperuser

To see all payment objects in admin area register the payments model in payments.admin



from  django.contrib  import  admin
from .models  import  Payment, UserWallet

class  PaymentAdmin(admin.ModelAdmin):
    list_display  = ["id", "ref", 'amount', "verified", "date_created"]

admin.site.register(Payment, PaymentAdmin)
admin.site.register(UserWallet)

Implementing deposit view

Create two views, one to initiate the payment and another to verify payments.
In payments.views



from django.shortcuts import render, redirect
from .models import Payment, UserWallet
from django.conf import settings

def initiate_payment(request):
    if request.method == "POST":
        amount = request.POST['amount']
        email = request.POST['email']

        pk = settings.PAYSTACK_PUBLIC_KEY

        payment = Payment.objects.create(amount=amount, email=email, user=request.user)
        payment.save()

        context = {
            'payment': payment,
            'field_values': request.POST,
            'paystack_pub_key': pk,
            'amount_value': payment.amount_value(),
        }
        return render(request, 'make_payment.html', context)

    return render(request, 'payment.html')


def verify_payment(request, ref):
    payment = Payment.objects.get(ref=ref)
    verified = payment.verify_payment()

    if verified:
        user_wallet = UserWallet.objects.get(user=request.user)
        user_wallet.balance += payment.amount
        user_wallet.save()
        print(request.user.username, " funded wallet successfully")
        return render(request, "success.html")
    return render(request, "success.html")

In payment.urls



from django.urls import path
from . import views

urlpatterns = [
    path('initiate-payment/', views.initiate_payment, name='initiate_payment'),
    path('verify-payment/<str:ref>/', views.verify_payment, name='verify_payment'),
]

The process flow goes like this;

User inputs an amount to fund his wallet
Clicks on pay then it takes them to page that displays the payment details
Then proceeds to pay by clicking the pay button, this will open a payment modal handled by paystack, when the process is complete paystack will send a request to the callback URL which we set up to confirm the details of the transaction.

Code for the payment pages can be found in the repo

Conclusion

We have successfully integrated Paystack into our Django application and deposited an amount successfully.

All codes can be found in this repository

Reference

Paystack docs

Connect with me on Twitter | Github
I hope this was helpful

Thanks for reading.

Use custom python scripts from any directory in windows

Joshua Hassan — Thu, 19 May 2022 18:12:10 +0000

In this one I am going to be showing you how you can run your python scripts from the terminal in directory on windows.

But first we shall look at what a PATH variable means and what ENVIRONMENTAL variables mean

Environmental Variable
An environment variable is a variable whose value is set outside the program, typically through functionality built into the operating system or microservice. An environment variable is made up of a name/value pair, and any number may be created and available for reference at a point in time.

PATH Variable
The PATH variable is an environment variable that contains an ordered list of paths that Linux will search for executables when running a command. Using these paths means that we do not have to specify an absolute path when running a command.

Now that we know what these terms mean we can get into the actual work
First step is to write our custom script, in this case I am using a script I developed to kill annoying tasks because task manager sometimes does not respond



import os
import sys

if len(sys.argv) < 2:
    print("[!] Usage: kill.py 'program name'")
    sys.exit()

program = sys.argv[1]
print(f"[*] Killing {program}")
os.system(f'taskkill -f -im {program}.exe')
sys.exit()

Next step is to create a folder for our custom scripts and add the folder path to environmental variables

After copying folder path click windows button and

Next step click on environmental variables

click on path and then edit at the bottom

click on new and then paste in the path to our custom folder

And voila we are ready to go. So to test this we open a new terminal and type out the name of our script in this case kill.py you should see the error output
Anyways we go ahead and test this

Use this to automate your boring tasks, Happy Coding Everyone :)

Making a fancy number guessing game

Joshua Hassan — Sun, 17 Apr 2022 00:59:52 +0000

This article is tailored towards new and inexperienced coders that want to start their coding careers

Demo of what we will be coding

C:\Users\Josh\Desktop>guessing.py
Enter player name: JoshTheCodingAddict

Hi JoshTheCodingAddict Welcome to my fancy number guessing game
=====================
| enter 10---Easy   |
| enter 20---Medium |
| enter 30---Hard   |
=====================

[*] Select difficulty level: 10
[*] You have 3 number of guesses left!
[!] Guess the lucky number: 9
[-] Sorry please try again

[*] You have 2 number of guesses left!
[!] Guess the lucky number: 8
[-] Sorry please try again

[*] You have 1 number of guesses left!
[!] Guess the lucky number: 7
[-] Sorry please try again

[!] Game over, type c to retry and q to quit game: c
[*] You have 3 number of guesses left!
[!] Guess the lucky number: 7
[-] Sorry please try again

[*] You have 2 number of guesses left!
[!] Guess the lucky number: 6
[-] Sorry please try again

[*] You have 1 number of guesses left!
[!] Guess the lucky number: 5
[-] Sorry please try again

[!] Game over, type c to retry and q to quit game: 4
[-] Wrong input
[!] Game over, type c to retry and q to quit game: c
[*] You have 3 number of guesses left!
[!] Guess the lucky number: 3
[-] Sorry please try again

[*] You have 2 number of guesses left!
[!] Guess the lucky number: 2
[+] Congratulations!! you won the game

[!] Thanks for playing!

Game requirements:

Player name
Game levels: Easy, Intermediate, Hard
Number of guesses: how many wrong guesses before ending the game
Fancy Instructions

Lets dive into it

Game logic

Users are presented a welcome message and asked to select the game difficulty
Then game starts and player has n number of chances to guess the lucky number
If the correct is number is inputed, player is presented with a congratulations message
If player runs out of guesses then player is presented with a message telling them they failed to guess the correct number and should retry or exit the game.

Without further ado lets get our hands dirty and write some code

Modules used:

random - used to generate pseudo random numbers

So we start by importing random

import random

Then setting our variables: player name, welcome message, congratulations message, failed message, difficulty level, lucky_number and number of guesses

player_name = input("Enter player name: ")
welcome_message = f"""
Hi {player_name} Welcome to my fancy number guessing game
=====================
| enter 10---Easy   |
| enter 20---Medium |
| enter 30---Hard   |
=====================
"""
print(welcome_message)
congratulations_message = "[+] Congratulations!! you won the game\n"
failed_message = "[-] Sorry please try again\n"
difficulty = int(input("[*] Select difficulty level: "))
lucky_number = random.randint(1, difficulty)
guesses = 3

Now start the game loop and write the logic for guessing and comparing guesses

while guesses >= 0:
    if guesses == 0:
        retry = input("[!] Game over, type c to retry and q to quit game: ")
        if retry == "c": guesses = 3
        elif retry == "q": break
        else: print("[-] Wrong input")
    else:  
        print(f"[*] You have {guesses} number of guesses left!")
        guessed = int(input("[!] Guess the lucky number: "))
        if guessed == lucky_number:
            print(congratulations_message)
            break
        else:
            print(failed_message)
            guesses = guesses - 1

print("[!] Thanks for playing!")

Full code below

import random
player_name = input("Enter player name: ")
welcome_message = f"""
Hi {player_name} Welcome to my fancy number guessing game
=====================
| enter 10---Easy   |
| enter 20---Medium |
| enter 30---Hard   |
=====================
"""
print(welcome_message)
congratulations_message = "[+] Congratulations!! you won the game\n"
failed_message = "[-] Sorry please try again\n"
difficulty = int(input("[*] Select difficulty level: "))
lucky_number = random.randint(1, difficulty)
guesses = 3
while guesses >= 0:
    if guesses == 0:
        retry = input("[!] Game over, type c to retry and q to quit game: ")
        if retry == "c": guesses = 3
        elif retry == "q": break
        else: print("[-] Wrong input")
    else:  
        print(f"[*] You have {guesses} number of guesses left!")
        guessed = int(input("[!] Guess the lucky number: "))
        if guessed == lucky_number:
            print(congratulations_message)
            break
        else:
            print(failed_message)
            guesses = guesses - 1

print("[!] Thanks for playing!")

Feel free to improve on this and Happy Coding :)

Leetcode Problem: Construct the Rectangle

Joshua Hassan — Wed, 13 Apr 2022 14:59:55 +0000

In this article I would be going over a solution to leetcode problem 492: Construct the Rectangle,

Two solutions were developed and I will be walking you through them

Solutuion 1

The function accepts a parameter area, in this example we would go with 16
area = 16
Next we create our answer dictionary variable to hold the factors of the target area
ad = {}
Also setup a temp list with maximum and minimum values of infinity
temp = [ float('inf'), float('-inf')]
First we wanna iterate over from 1 till the square root of the target area + 1 to avoid duplicates
for 1,2...sqrt(16)+1 --> 5
For every iteration, if we find a factor of that number then we want to save it to the answer dictionary

 # 16/1
 # 16/2
 # 16/3
 # 16/4
 ad = {'1':'16', '2':'8', '4':'4'}

Now we can iterate through the answer dictionary to select the best length and width combination with the lowest absolute difference

 for k,v in ad:
    if abs(k-v) < abs(temp[0]-temp[1])
    temp[0], temp[1] = min(k, v), max(k,v)
    return temp

At the end of this process we have the answer in temp list

Code Below

import math
class Solution:
    def constructRectangle(self, area: int) -> List[int]:
        answer_dict = {}
        temp = [float('inf'),  float('-inf')]
        for n in range(1, int(math.sqrt(area))+1):
            if area%n == 0:
                answer_dict[n] = area // n
        for k, v in answer_dict.items():
            if abs(temp[0] - temp[1]) > abs(k-v):
                temp[0], temp[1] = max(k, v), min(k, v)
        return temp

The first solution was long and it could be made a lot simpler
This second solution makes use of one list to keep the prospective lengths and breadths
Easy to understand

class Solution:
    def constructRectangle(self, area: int) -> List[int]:
        ans = []
        for i in range(1, int(sqrt(area))+1):
            j = area // i
            if i * j == area:
                if i <= j:
                    ans.append([max(i,j), min(i,j)])
        return ans[-1]

A little task for the readers, what is the time and space complexities of both solutions
Also do let me know if you have a better solution, or any improvements to be made

Happy Cocding :)

Understanding Command Line Arguments by making a simple file searcher

Joshua Hassan — Tue, 12 Apr 2022 01:38:52 +0000

The sys.argv Array

There are various ways of handling Python command line arguments, but what you need to know is that the underlying support for all Python command line arguments is provided by sys.argv.

The examples will show you how to handle the python command line arguments stored in sys.argv and to solve a few problems that come when trying to access them.

We will learn how to

Access the contents of sys.argv
Process whitespaces in python command line arguments
Handle errors while processing python command line arguments

Displaying Arguments

The sys module exposes an array named argv that includes the following:

argv[0] contains the name of the current Python program.
argv[1:], the rest of the list, contains any and all Python command line arguments passed to the program.

for example

Line 1 imports the python module sys
Line 3 gives the name of the program by getting the first item in the list sys.argv
Line 5 displays the python command line arguments by getting all the remaining items of the list sys.argv

Running the script above with a list of arguments as shown



python argv.py cat dog sheep friends eleven
Name of script:                argv.py
Arguments passed to script:    ['cat', 'dog', 'sheep', 'friends', 'eleven']

The output confirms that the content of sys.argv[0] is the Python script argv.py, and that the remaining elements of the sys.argv list contains the arguments of the script, ['cat', 'dog', 'sheep', 'friends', 'eleven'].

Escaping Whitespace Characters

On Linux, whitespaces can be escaped by doing one of the following:

Surrounding the arguments with single quotes (')
Surrounding the arguments with double quotes (")
Prefixing each space with a backslash () Without one of these solutions, the script will store two arguments instead of one as in the example below



C:\Users\UserName\Desktop\DevPosts>python argv.py "cat dog"
Name of script:                argv.py
Arguments passed to script:    ['cat dog']

C:\Users\UserName\Desktop\DevPosts>python argv.py cat dog
Name of script:                argv.py
Arguments passed to script:    ['cat', 'dog']

Handling Errors

Many things can go wrong, so it’s a good idea to provide the users of your program with some guidance in the event they pass incorrect arguments at the command line. For example, kill.py expects one argument, and if you omit it, then you get an error:



Traceback (most recent call last):
  File "C:\Users\UserName\Desktop\DevPosts\searcher.py", line 4, in <module>
    print("File To Search:                {}".format(sys.argv[1]))
IndexError: list index out of range

The Python exception IndexErroris raised, and the corresponding traceback shows that the error is caused by the expression arg = sys.argv[1]. The message of the exception is list index out of range. So you didn’t pass an argument at the command line, so there’s nothing in the list sys.argv at index 1.

This is a common problem type that can be addressed in a few different ways. For this initial example, you’ll keep it brief by including the expression arg = sys.argv[1] in a try block. Modify the code as follows:



import sys

try:
    file_to_search = sys.argv[1]
except IndexError:
    raise SystemExit("Usage: {} <file_to_search>".format(sys.argv[0]))

The expression is included in a try block. Line 6 raises the built-in exception SystemExit. If no argument is passed to searcher.py, then the process exits with a status code of 1 after printing the usage. Note the addition of sys.argv[0] in the error message. It shows the name of the program in the usage message. Now, when you run the same program without any Python command line arguments, you can see the following output:



C:\Users\UserName\Desktop\DevPosts>searcher.py
Usage: C:\Users\UserName\Desktop\DevPosts\searcher.py <file_to_search>

Now that we have made ourselves familiar with how sys.argv works, we can dive into our little project which is to code a simple file searcher

first we import the sys module



import sys

Next we write checks to make sure we get the right number of arguments from the user



if len(sys.argv) < 3:
    sys.stderr.write("Error: Usage " + sys.argv[0] + " <filename> <words>")
    sys.stderr.flush()
    exit(2)
else:
    filename = sys.argv[1]
    needle = sys.argv[2]

initalize counter for the number of times we find our needle



counter = 0

Now we open our file in read mode



file_handler = open(filename)

Next step is to iterate through the file while separating words in each line by a delimeter (space) and making it into a sentence



for line in file_handler.readlines():
        sentences = line.split(" ")

Then iterate through the sentences word by word and compare against our needle, and if it is a match, we increment counter



for word in sentences:      
        # this checks if the last word is a new line character and eliminates it        
    if word == sentences[-1]:
        word = word[:-1]            
    if word == needle:              
        counter += 1

Finally we print the number of times the word was found



print (str(counter) + " times " + needle + " appears")

The full code



import sys

if len(sys.argv) < 3:
    sys.stderr.write("Error: Usage " + sys.argv[0] + " <filename> <words>")
    sys.stderr.flush()
    exit(2)
else:
    filename = sys.argv[1]
    needle = sys.argv[2]

counter = 0
file_handler = open(filename)

for line in file_handler.readlines():   
    sentences = line.split(" ")         
    for word in sentences:              
        if word == sentences[-1]:       
            word = word[:-1]            
        if word == needle:              
            counter += 1                

print (str(counter) + " times " + needle + " appears")

In this tutorial, you've learned about Python command line arguments. You should feel a little prepared to apply this new skills to your code.

Happy Coding :)

DEV Community: Joshua Hassan

🚀 WSGI vs ASGI — Sync vs Async in Python Web Development (Made Simple)

🧠 The Basics

🔄 WSGI vs ASGI

🧱 Synchronous (WSGI)

⚡ Asynchronous (ASGI)

🧪 Real-World Scenario: 3 Users, Same Endpoint

SYNC Version (blocking):

ASYNC Version (non-blocking):

🤔 Wait… Doesn’t await Still “Wait”?

🌀 What is a Coroutine?

🧠 Final Thoughts

💬 TL;DR

📚 References and Further Reading

Building a Decentralized Voting System with Smart Contracts

Table of Contents

What are Smart Contracts?

Smart Contracts in Voting

Building a Voting System with Smart Contracts

Key Variables in Our Voting Smart Contract

Key Functions of Our Voting Smart Contract

1. Creating a Poll

2. Registering as a Candidate

3. Voting

4. Ending a Poll

Benefits and Challenges

Benefits

Challenges

Resources to Learn More

Conclusion

Mastering Soft Delete

Write Faster Django Queries

Introduction

Prerequisites

What is Django ORM

How to view database performance

The N+1 problem

Ways to write faster and more efficient queries

1. Use select_related() and prefetch_related():

2. Use filter() instead of get():

3. Use only() or defer():

4. Use subqueries

5. Use Q objects for complex queries:

6. Use annotations:

7. Use aggregation:

8. Use caching:

9. Use indexing:

10. Use database-level query optimization techniques:

11. Use third-party libraries:

Conclusion

Resources

JS vs TS: A Comprehensive Guide to Choosing the Right Programming Language

What is JavaScript?

What is TypeScript?

JavaScript vs TypeScript

1. Type Checking:

2. ES6 Features:

3. Classes:

4. Namespaces:

5. Compilation:

6. Type Annotations:

What is API Latency

What is API latency?

What is the response rate?

What is server response time?

What is a good server response time?

What is a bad server response time?

Overview of APIs latency rate vs response rate

What causes high latency?

How can the latency of an API be monitored?

Some ways to reduce latency

Integrating Paystack payments in Django website

Introduction

Prerequisites

Project Setup

Creating models

User registration and login

Implementing deposit view

Conclusion

Reference

🤔 Wait… Doesn’t `await` Still “Wait”?