DEV Community: Ajisafe Victor Oluwapelumi

Understanding Value and Pointer Receivers in Go: Building a Crypto Tracker

Ajisafe Victor Oluwapelumi — Thu, 06 Nov 2025 00:56:05 +0000

I picked up Go recently while building the backend of a crypto tracker. This tracker allows users to manage their cryptocurrency holdings and calculate their wallet value in real-time. One of my favorite learnings so far is value receivers and pointer receivers, and how everything works under the hood.

How Go Passes Arguments

Go passes arguments by value, not by reference. This means it creates a copy of the argument and passes that copy to the function. Understanding this is crucial to writing efficient Go code.

Value Receivers: Working with Copies

When you use a value receiver, Go creates a copy of the struct. Any modifications you make inside the function only affect the copy, not the original.

type Wallet struct {
    User       string
    TotalValue float64
}

// Value receiver - receives a copy
func (w Wallet) UpdateValue(newValue float64) {
    w.TotalValue = newValue  // Only modifies the copy
    fmt.Println("Inside function:", w.TotalValue)
}

func main() {
    wallet := Wallet{User: "pelumi", TotalValue: 1000.0}
    wallet.UpdateValue(5000.0)

    fmt.Println("Outside function:", wallet.TotalValue)
}

Output:

Inside function: 5000
Outside function: 1000

The original wallet.TotalValue remains 1000 because we modified a copy. When the function returns, the copy is discarded (removed from the stack), and our changes are lost.

Pointer Receivers: Modifying the Original

Pointer receivers solve this by passing the memory address of the struct instead of a copy. When you pass an address, Go still passes it by value, but now you have an address that points to the original data.

// Pointer receiver - receives a pointer (address)
func (w *Wallet) UpdateValue(newValue float64) {
    w.TotalValue = newValue  // Modifies the original
    fmt.Println("Inside function:", w.TotalValue)
}

func main() {
    wallet := Wallet{User: "pelumi", TotalValue: 1000.0}
    wallet.UpdateValue(5000.0)  // Go automatically passes &wallet

    fmt.Println("Outside function:", wallet.TotalValue)
}

Output:

Inside function: 5000
Outside function: 5000

Now both print 5000 because we modified the original through its address. Go automatically handles the dereferencing (you don't need to write (*w).TotalValue), making the syntax clean.

Real-World Example: My Crypto Tracker

In my crypto tracker, I use pointer receivers when updating wallet data:

type Wallet struct {
    ID         string
    User       string
    TotalValue float64
    Holdings   []Holding
    UpdatedAt  time.Time
}

// Pointer receiver because we need to modify the wallet
func (w *Wallet) CalculateTotalValue(priceService *PriceService) error {
    total := 0.0

    for _, holding := range w.Holdings {
        price, err := priceService.FetchCoinPrice(holding.Coin)
        if err != nil {
            return err
        }
        total += price * holding.Amount
    }

    w.TotalValue = total      // Modifies the original wallet
    w.UpdatedAt = time.Now()  // Updates timestamp
    return nil
}

If I used a value receiver here, the calculated TotalValue and UpdatedAt would never be saved to the original wallet.

The Stack vs Heap Trade-off

Here's where it gets interesting. Value receivers are faster because they use the stack, but pointer receivers can be slower because they may require the heap.

Stack (Fast)

When you use value receivers, Go allocates the copy on the stack. The stack is fast because:

Memory is automatically managed (allocated and freed when functions return)
Memory is local and cache-friendly
No garbage collector involvement

func (w Wallet) GetUser() string {
    return w.User  // Fast: uses stack memory
}

Heap (Slower, but Necessary)

When you use pointer receivers, Go might allocate the variable on the heap if it "escapes" the function scope. This happens because the address could be referenced later in the program, so Go can't safely discard it when the function returns.

func (w *Wallet) UpdateAndReturn() *Wallet {
    w.TotalValue = 10000
    return w  // Address escapes, so w lives on the heap
}

The heap is slower because:

The garbage collector must track and clean up these allocations
Memory access is less cache-friendly
Allocation and deallocation take more time

However, this trade-off is usually worth it when you need to modify large structs or avoid expensive copies.

When to Use Each

Use Value Receivers When:

You don't need to modify the struct
The struct is small (a few fields)
You want maximum performance for read-only operations

func (w Wallet) IsEmpty() bool {
    return len(w.Holdings) == 0  // Just reading, no modifications
}

func (w Wallet) GetUserInfo() string {
    return fmt.Sprintf("User: %s, Value: $%.2f", w.User, w.TotalValue)
}

Use Pointer Receivers When:

You need to modify the struct
The struct is large (copying would be expensive)
You want consistency (if some methods use pointers, use them everywhere)

func (w *Wallet) AddHolding(holding Holding) {
    w.Holdings = append(w.Holdings, holding)  // Modifies original
}

func (w *Wallet) ClearHoldings() {
    w.Holdings = []Holding{}  // Modifies original
}

A Common Pattern: Mixing Both

In practice, if you have any pointer receiver methods, it's best to use pointer receivers for all methods on that type for consistency:

type Wallet struct {
    User       string
    TotalValue float64
}

// Even though this doesn't modify, use pointer for consistency
func (w *Wallet) GetUser() string {
    return w.User
}

// This modifies, so it needs a pointer
func (w *Wallet) SetUser(user string) {
    w.User = user
}

What I've Learned

Coming from C, I understood pointers conceptually, but Go's implementation adds an interesting layer. The automatic dereferencing makes pointer receivers feel natural to use, and the compiler's escape analysis intelligently decides when to use the heap vs stack.

The key insight: value receivers are best when you don't intend to modify the argument, while pointer receivers are perfect when you want to modify a passed argument or when you want to avoid copying large values.

Virtual Environments: My "Aha!" Moment

Ajisafe Victor Oluwapelumi — Tue, 25 Feb 2025 14:34:43 +0000

This is going to seem weird, but I have seen "virtual environments" flying around since I started coding in 2022. Yet, I only just got the hang of them. For the longest time, they looked like some overly complex sorcery, and I would shy away every time someone mentioned them.

Fast forward to now, I am sitting here wondering how I have been surviving without them all this time.

Do not get me wrong, I had used virtual environments before. I knew how to spin one up when following tutorials, but it was always just one of those "do this because they said so" moments. I never really understood the power they wielded. But recently? Oh boy, things changed! I finally hacked how powerful they can be when properly integrated into a project, and now I cannot imagine coding without them.

So, here is how I have been rolling with virtual environments lately.

What Even Is a Virtual Environment?

If you are like how I used to be, you might have nodded along when people talked about virtual environments without actually knowing what they were. A virtual environment is basically a self-contained workspace where you can install project-specific dependencies without messing up your system-wide Python setup.

Think of it like a bubble for your project, everything it needs stays inside, away from global Python, keeping things clean and conflict-free. No more worrying about breaking other projects because some library decided to update itself to an incompatible version.

How To Setup Virtual Environments

1. Create a virtual environment

python -m venv my_env

This creates a new directory my_env, which holds all the virtual environment goodies.

2. Activate it

On Windows:

  my_env\Scripts\activate

On macOS/Linux:

  source my_env/bin/activate

Once activated, your terminal will show (my_env), meaning you are now inside the isolated environment.

3. Install Dependencies

pip install requests flask

Boom! These packages are now installed only inside my_env, not system-wide.

4. Deactivate When Done

deactivate

This takes you back to normal, global Python.

Why You Should Use Virtual Environments

No More "It Works on My Machine" Nightmares - With a virtual environment, dependencies are locked to specific versions, so no more "why does it work for you but not for me?"
Easy Project Switching - One can now hop between projects without dependency conflicts.
Better Collaboration - When sharing code, others can recreate exact environment using a requirements.txt file:

  pip install -r requirements.txt

Now that I have finally embraced virtual environments, I cannot believe I was coding without them for so long. If you are like I was, seeing people talk about them but never really using them, trust me, it is worth the 5 minutes to set up. Your projects (and future self) will thank you!

How Dictionary Lookup Operations Are O(1)

Ajisafe Victor Oluwapelumi — Thu, 05 Sep 2024 18:16:38 +0000

Imagine you have a magical book that lets you look up any word instantly. You don’t need to flip through pages or search for the right letter section. You just say the word, and poof, the meaning appears immediately.

In programming, we have something very similar to this magical book: dictionaries (also called hashmaps). They are special data structures where you can store things in a way that makes finding them super fast, no matter how much you’ve stored.

But how does this work?

What’s a Dictionary in Programming?

A dictionary in programming is like a real-life dictionary, but instead of words and meanings, it stores keys and values. You give it a key (something unique like a number, a name, or a word), and it will give you back its value (like a description, number, or some other information related to the key).

For example:

fruit_colors = {
    "Apple": "Red",
    "Banana": "Yellow",
    "Grapes": "Purple"
}

Key: "Apple"
Value: "Red"

The Magic Behind O(1) Lookup

So, how does the dictionary give you answers so quickly? The secret is something called hashing.

Let’s think about it this way: if you had a huge pile of toys and someone said, "Find me the red car" you would have to look through the whole pile one by one, that would take time, especially if there are lots of toys.

Now, imagine if every toy had a magical sticker with an exact spot where it should go on a shelf. Every time you put a toy away, it goes straight to its specific spot. So, if you wanted the red car, you would know exactly where it is without looking through everything.

This is exactly how a hashmap works. When you add something to a dictionary, a special function (called a hash function) creates a magical "sticker" (called a hash), which tells the dictionary where to store the value.

When you ask for that value later using its key, the dictionary uses the same "sticker" to go straight to the spot and grab the value in one step. This quick access, no matter how much stuff you have, is called constant time or O(1) in Big O notation. It means the lookup time doesn’t grow even if you have millions of items stored.

Checking If a Key Exists in a Dictionary

When working with dictionaries, one common task is checking if a specific key exists. For example, in our magical toy shelf, one might want to know if a red car is already on the shelf before adding another one.

There are two ways you might write this check in Python:

if key in dictionary
if key in dictionary.keys()

At first glance, both seem to do the same thing however, there is a big difference in efficiency, and here is why.

if key in dictionary – The Fast, Direct Way
When you write if key in dictionary, Python automatically looks for the key in the dictionary’s "shelf" of keys. It knows exactly where to check, thanks to the hashing system we talked about earlier. This lookup is done in O(1) time, meaning it is super fast.

if key in dictionary.keys() – The Slower, Extra Work Way
On the other hand, if you write if key in dictionary.keys(), you are explicitly asking Python to first pull out all the keys from the dictionary and store them in a special "view" object. Then, Python checks if the key is in that view. While this still works, it is slower because you are adding an extra step: creating the view of all the keys.

Always use if key in dictionary. It is the faster, more efficient way to check if a key exists in a dictionary.

Dictionaries in programming are powerful tools, allowing you to store and retrieve data quickly, thanks to the magic of hashing. With constant-time lookups (O(1)), they enable you to efficiently manage large amounts of data without worrying about performance issues. Whether you are checking if a key exists or retrieving a value, dictionaries are your go-to structure for fast and effective operations.

Have any experiences with using dictionaries? Share your thoughts and tips in the comments below!

Goroutines and sync.WaitGroup in Golang

Ajisafe Victor Oluwapelumi — Thu, 11 Jan 2024 16:13:37 +0000

Creating a booking app with Golang has been a thrilling experience, filled with challenges and chances to learn. I came across something interesting while working on managing Goroutines using sync.WaitGroup. It reminded me of the asynchronous and await functionality in Node.js, providing a strong way to handle multiple tasks at the same time in Golang. However, when I initially tried to add sync.WaitGroup to my code, I encountered an unexpected error, I found out that it was crucial to create an instance of sync.WaitGroup for it to work smoothly.

The Importance of Goroutines

Goroutines are a key feature in Golang that allow functions to run concurrently. They are lightweight, making them great for handling many tasks simultaneously without affecting performance. To make Goroutines even more efficient, I explored using sync.WaitGroup.

Understanding Sync.WaitGroup

In Golang, sync.WaitGroup is designed to coordinate Goroutines. It keeps track of the number of active Goroutines, making it useful in situations where you want to make sure all concurrent tasks are completed before moving on.

The Learning Experience

While trying to add sync.WaitGroup to my booking app, I faced an error that made me realize that creating an instance of sync.WaitGroup is necessary before using its methods. The three main methods - Add(), Wait(), and Done() - are crucial for synchronization. If we try to call sync.WaitGroup.Add(1), the Go compiler will give an error because Add is not a function of the sync.WaitGroup type that can be called directly. It's a method that needs an instance of sync.WaitGroup to be called upon.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // Create an instance of sync.WaitGroup
    var wg sync.WaitGroup

    // Example Goroutine
    wg.Add(1)
    go func() {
        // Your concurrent task logic here
        fmt.Println("Hello World!")
        wg.Done()
    }()

    // Wait for all Goroutines to finish
    wg.Wait()
}

By creating an instance of sync.WaitGroup and using its methods in the right context, I seamlessly integrated it into my booking app. This ensured smooth coordination between Goroutines.

If you have any stories about using sync.WaitGroup, feel free to share them in the comments below. I would love to hear about your experiences!

The Journey to Becoming a Software Engineer: My Year at ALX

Ajisafe Victor Oluwapelumi — Fri, 20 Oct 2023 22:58:55 +0000

On August 15, 2022, I began a journey that changed my life's course. The ALX Software Engineering program was my choice. At first, I was both excited and uncertain about what lay ahead. I'd been self-taught, but I longed for structured learning and a community of like-minded individuals. ALX was my answer.

Today, on October 20, 2023, as I graduate from this transformative program, I'm brimming with excitement and a profound sense of achievement. The past year has been a remarkable journey of self-discovery and growth, one I'm eager to share with you in this post. It's been a time of refining my skills and broadening my horizons, and I can't wait to see where this newfound knowledge will lead me.

My year at ALX was like an exciting journey where I not only became a better coder but also honed my problem-solving skills. The challenging curriculum and unwavering support from my fellow learners and mentors transformed everyday problems into chances for personal growth. My ability to think critically, debug, and solve complex problems all improved significantly, giving me the confidence to handle challenges with ease.

Yet, one big realization during this year was the strength of community. The program created an atmosphere where working together was key. It wasn't only about standing out individually but also about supporting each other. The feeling of togetherness and sharing knowledge with my peers meant a lot. It taught me that the journey becomes more special when you're alongside others who have the same passion.

While at ALX, I discovered a knack for explaining complex technical stuff in simple terms. This newfound passion for making the complicated seem easy has become a vital part of my journey. Feel free to check out my articles here for a deeper dive into topics that pique my interest.

As I gaze ahead, I see a world filled with opportunities. In the next 5-10 years, I imagine using my Software Engineering skills to make a positive impact on communities in Africa and beyond. My time at ALX has armed me with not just technical skills, but also the mindset and determination to effect change. I'm thrilled to apply my knowledge to tackle real-world issues and devise solutions that can benefit society.

In summary, my year at ALX Africa has been an exceptional chapter in my software engineering journey. It transformed me, broadening my horizons, honing my skills, and instilling a deep sense of purpose. I found my community, uncovered a passion for technical writing, and gained the confidence to tackle complex challenges. The future holds abundant promise, and I can't wait to seize its opportunities.

I invite you to dive into my articles here and reach out to me. If you're on a similar path or have a story to share, I'd be thrilled to connect with you. Together, let's keep learning, growing, and inspiring one another.

Composition and Inheritance: From Cars to Cars

Ajisafe Victor Oluwapelumi — Mon, 28 Aug 2023 23:35:44 +0000

Hello and welcome! A while back, I tackled a real-world problem through Forage, and the company at the center was Lyft. While much of the material covered wasn't entirely new, what intrigued me were the concepts of composition and inheritance. These concepts played a central role in shaping Lyft's backend infrastructure and I thought to share my newfound knowledge with you. Stay tuned.

Composition: Assembling a Car

Let's say we are putting together a car. A car is made up of lots of different parts, and instead of making the whole car all at once, we start by making smaller pieces. Then, we fit these pieces together to build the complete car. This way of building things is called composition. It's a helpful approach because it gives our car flexibility. We can easily add or remove pieces as needed. This makes our finished car more versatile.

Let's see an example:

class Engine:
    def start(self):
        pass

class Wheels:
    def rotate(self):
        pass

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.engine = Engine()
        self.wheels = Wheels()

Here, we are defining three classes: Engine, Wheels, and Car. Engine and Wheels represent parts of a car while the Car class brings together an engine and wheels to construct a complete car.

We see that each part has its own functionality with specific responsibilities. The engine starts, the wheels rotate and the car cars (I thought that would come out right).

Inheritance: Family Traits Passed On

Inheritance is in the name, we inherit traits from our parents. Same applies here as our classes inherit characteristics from their base class. We can create new things based on existing things and pass down their characteristics. This approach makes us more efficient as we do not need to create things from the start.

Let's see an example:

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

class Car(Vehicle):
    pass

# Creating an instance of Car
my_car = Car("Toyota")
print(f"My car's brand is {my_car.brand}")

The Car class inherits the brand attribute from the Vehicle class without needing to redefine the __init__ method. The Car class inherits all attributes and methods from the Vehicle class while also retaining the ability to redefine and implement its own variations.

You could use both composition and inheritance together to get the best out of your application. If you'd like to explore how I employed both to address the Lyft challenge, you can find the code here.

If you've got stories about using composition and inheritance, I would love to hear them. Drop a comment below and share your experiences!

Exploring the Magic of async/await in JavaScript!

Ajisafe Victor Oluwapelumi — Thu, 10 Aug 2023 20:20:14 +0000

Today, we're going to uncover async and await. In JavaScript, there are some tasks that can take some time, like asking for information from the internet or reading special files. Instead of making the whole computer wait for these tasks to finish, JavaScript allows other tasks to be handled at the same time while it waits for the response from time-taking tasks. Sometimes, we want to wait for the response before starting other tasks, and that's where async and await comes in.

async

In simple words, async is a special word we put in front of a function to tell our computer, "Hey, inside this function, there might be things that take a bit of time to finish."

async function getData() {
  // Asynchronous operation
}

await

We use the await keyword inside an async function and it's a way to tell our computer, "Hey, take a break and pause execution here until this thing is done."

async function main() {
  const result = await getData(); // Pauses until getData() is resolved
  console.log(result);
}

Let's explore the use of async and await with some examples.

Example 1: Without async/await

// Imagine fetching a cat fact from an API using Promises

function main() {
  const url = 'https://catfact.ninja/fact';
  const response = fetch(url);
  console.log(response.fact); // Oops! This won't work as expected
  console.log('Cat Fact Ninja!');
}

function fetch(url) {
  return new Promise((resolve, reject) => {
    // Fetch the cat fact from the API
  });
}

main();

In this example, we have two functions: main() and fetch(url).

The fetch(url) function takes a URL as input and returns a Promise (a Promise ensures that our request is completed). Inside this Promise, we request a cat fact from the internet.

The main() function starts by setting a URL for a cat fact API. Then it calls the fetch(url) function to get the cat fact data. Since fetch(url) returns data from the internet, it doesn't immediately provide the result, the function takes time. Therefore, when we try to log response.fact, it won't work correctly. The next console.log() statement and 'Cat Fact Ninja!' will be printed before the fetch(url) is resolved and this is not what we want. We can fix this in the next example.

Example 2: With async/await

// Now let's fetch a cat fact using async/await

async function main() {
  const url = 'https://catfact.ninja/fact';
  const response = await fetch(url); // We await the promise to finish
  console.log(response.fact); // This works perfectly now!
  console.log('Cat Fact Ninja!');
}

function fetch(url) {
  return new Promise((resolve, reject) => {
    // Fetch the cat fact from the API
  });
}

main();

In this example, we've made a slight change by using the async keyword in the main() function.

The main() function is now marked as async, which means we can use the await keyword inside it. When await is used before calling fetch(url), it pauses the execution of the main() function until we get the result we want. This way, the cat fact data is fetched and assigned to the response variable before moving on. Now, when we log response.fact, it will correctly show the cat fact fetched from the API because we were waiting for the function to return using await.

async and await help us do cool things with our code, even if those things take time. If you've got thoughts or stories about using them, I'd love to hear them. Drop a comment below and share your experiences, your feedback means a lot!

Navigating One-To-Many Relationship in MySQL

Ajisafe Victor Oluwapelumi — Thu, 03 Aug 2023 18:20:44 +0000

While developing the backend for Vim Quizzer, I encountered a challenge in handling a list of incorrect questions for our question class due to MySQL's lack of direct support for list structures. To address this, I created an Incorrect Question class and established a One-to-Many relationship between the Question class and the Incorrect Question class, successfully implementing a list structure. In this post, I will explain how I achieved that and also shed light on how the One-to-Many relationship works.

Before we dive into the technicalities, let me give a brief overview of the project that kick started this adventure. Vim Quizzer is an engaging platform designed to help users learn Vim commands through a series of multiple-choice questions that test their knowledge of this command-line text editor, commonly used on Linux machines. If you're eager to put your Vim skills to the test, you can try the quiz here, the source code is also available here.

The Challenge

MySQL serves as the relational database management system, where we store the questions for our web application. As depicted above, our database structure includes a table named questions with 4 columns: question_id, question, correct_answer, and incorrect_answers. The question_id column holds the question id while the question column accepts a string to store the question itself, the correct_answer column also takes a string to store the accurate response for the question. On the other hand, the incorrect_answers column requires a list of strings to store the various incorrect responses for the question.

However, MySQL lacks built-in support for list structures so we can't have an incorrect_answers column. To address this, we had to devise an alternative approach, and that's where One-to-Many relationship came into play.

One-To-Many Relationship

As illustrated above, we have established an incorrect answers table, which comprises the incorrect_answer_id column, the question_id column, and the incorrect_answer itself. It is evident that the question_id serves as a shared column between the question table and the incorrect_answer table. The incorrect answers to the question in our first illustration are now stored accordingly.

Here, all 3 incorrect answers possess the same question_id, signifying that they correspond to one particular question in our database. This linkage ensures that each incorrect answer is appropriately associated with its corresponding question.

To enable the incorrect_answers attribute to return the list of all incorrect answers associated with a question, we implemented the following code in our Question class.

 # Create list of incorrect answers
 incorrect_answers = relationship("IncorrectAnswer", backref="question", cascade="all, delete-orphan")

In our implementation, we take advantage of SQLAlchemy's relationship method to establish a seamless link between incorrect_answers and the Incorrect Answer class. Thanks to the backref parameter, accessing incorrect answers from a given question becomes a breeze, eliminating the need for complex queries or tangled joins. See snippet below.

>>> type(question1)
<class '__main__.Question'>
>>> question1.question
'What is the Vim command to save and exit a file?'
>>> question1.correct_answer
':wq'
>>> question1.incorrect_answers
[":w", ":q!", ":s"]

Furthermore, the cascade parameter works wonders in ensuring data integrity. When we remove a question, all its associated incorrect answers are gracefully deleted as well. This intelligent handling of cascading deletes prevents any orphaned records from cluttering up the database, maintaining a tidy and organized data structure. This solution brings simplicity and efficiency to the management of question and incorrect answer relationship, streamlining the entire process for optimal performance.

As mentioned earlier, this implementation is at the core of our backend, making it the backbone of our entire application. Witnessing this implementation work in real-time was truly refreshing. The One-To-Many relationship unlocks the true power and practicality in our application, allowing us to seamlessly manage questions and their corresponding incorrect answers with utmost efficiency.

I hope this explanation provided a clear understanding of the One-To-Many relationship. Feel free to share your thoughts and experiences in the comments. Whether you have explored this concept before or are eager to delve into it, your insights and feedback are appreciated.

Setting up SSL Certificate with Nginx

Ajisafe Victor Oluwapelumi — Tue, 25 Jul 2023 21:45:05 +0000

One of the essential steps to ensure secure connections on any website or web application is to set up SSL (Secure Socket Layer) certificates.

SSL certificates encrypt data transmitted between a user's browser and the web server, safeguarding sensitive information from prying eyes. In this post, we will walk through the process of setting up an SSL certificate with Nginx, a powerful and widely-used web server.

Prerequisites:

Before we get started, make sure you have the following prerequisites in place:

A domain name (e.g. www.example.com).
A server with Nginx installed and running.

Obtaining an SSL Certificate:

The first step is to obtain an SSL certificate, and we will use Let's Encrypt, a free and widely recognized certificate authority, to do this. Let's Encrypt offers an automated certificate issuance process using the Certbot tool.
To get started, follow these steps:

Step 1: Install Certbot

sudo apt update
sudo apt install certbot python3-certbot-nginx

Step 2: Obtaining the SSL Certificate

sudo certbot certonly --standalone -d <your-domain-name> --non-interactive --agree-tos --email <your-email>

Certbot will handle the entire certificate issuance process for you. After a successful run, the SSL certificate and private key will be stored on your server.

Nginx Configuration for SSL:

Now that we have the SSL certificate, let's configure Nginx to enable SSL on our domain.
Locate your Nginx configuration file for the domain (usually found in /etc/nginx/sites-available/default), and add the following lines within the server block:

server {
    listen 443 ssl;
    listen [::]:443 ssl;

    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;

    server_name <your-domain-name>;

    ssl_certificate /etc/letsencrypt/live/<your-domain-name>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<your-domain-name>/privkey.pem;

    location / {
        try_files $uri $uri/ =404;
    }
}

The listen 443 ssl; and listen [::]:443 ssl; lines enable SSL on port 443, the default HTTPS port.
The ssl_certificate and ssl_certificate_key directives point to the SSL certificate and private key files obtained from Certbot.
The location / block handles the regular web page requests.

Configuring HTTP to HTTPS Redirection:

To redirect HTTP traffic to HTTPS, add the following server block for port 80 in the same Nginx configuration file as the above:

server {
    listen 80;
    listen [::]:80;

    server_name <your-domain-name>;

    location / {
        return 301 https://$host$request_uri;
    }
}

The location / block performs an HTTP 301 (permanent) redirect to the HTTPS version of the same URL (https://$host$request_uri), effectively enforcing secure connections over HTTPS for the entire website.

Testing and Reloading Nginx:

Before applying the changes, test your Nginx configuration for syntax errors:

sudo nginx -t

If the test is successful, reload Nginx to apply the new configuration:

sudo systemctl reload nginx

Remember to replace with your actual domain name in the configuration. Additionally, you should customize the location blocks and server settings according to your specific requirements.

Unleashing the Copy-Paste Chuckles

Ajisafe Victor Oluwapelumi — Sat, 15 Jul 2023 19:49:21 +0000

Today, we delve into the intriguing world of copy-paste operations. We explore a fascinating challenge of achieving 'n' 'H' characters in the most efficient way possible.

Here is what is expected:
Given a number n, write a method that calculates the fewest number of operations needed to result in exactly 'n' 'H' characters in the file.

Through careful calculation and strategic maneuvers, we were able to unlock the secret to reaching the desired 'n' 'H' characters with the fewest number of operations.

Code Snippet

def minOperations(n):
    """ Minimum Operations Function. """
    if n <= 1:
        return 0

    # Set the minimum operation variable to 0
    min_operations = 0
    # Set the current length variable to 1 as we start with 1 character 'H'
    current_length = 1
    # Set the clipboard variable to 0 as we are not copying anything yet
    clipboard = 0

    # Loop until current length is equal to n
    while current_length < n:
        # If n is divisible by current length, we can copy all
        if n % current_length == 0:
            # This is the only time we can copy
            clipboard = current_length
            # Minimum operation is incremented by 1 because we copied
            min_operations += 1

        # Paste the clipboard
        current_length += clipboard
        # Minimum operation is incremented by 1 because we pasted
        min_operations += 1

    # Return minimum operation
    return min_operations

Explanation

The minOperations function takes an integer n as input, representing the desired number of 'H' characters in the file. It returns the fewest number of operations needed to reach the target.

To start, the function checks if n is less than or equal to 1. If so, it means that the desired number of 'H' characters is already present in the file, and no operations are needed. In this case, the function returns 0.

Next, the function initializes some variables. min_operations is set to 0 to keep track of the total number of operations performed. current_length is set to 1 as we start with a single 'H' character in the file. The clipboard variable is set to 0 since there is nothing in the clipboard initially.

The function then enters a while loop that continues until the current_length is equal to n. Inside the loop, it checks if n is divisible by the current_length. If it is, it means that the current length is a divisor of n, and it would be optimal to perform a Copy All operation. The function updates the clipboard variable to hold the value of current_length since all characters can be copied at once. Additionally, min_operations is incremented by 1 to account for the copy operation.

After that, the function performs a Paste operation by incrementing current_length by the value of clipboard. This increases the number of characters in the file. min_operations is incremented by 1 to track the paste operation.

If n is not divisible by current_length, the function simply performs a Paste operation by incrementing current_length by clipboard and increments min_operations by 1.

Once the loop completes and the current_length reaches n, the function returns the value of min_operations, which represents the fewest number of operations needed to achieve exactly 'n' 'H' characters in the file.

Example Usage

>>> minOperations(4)
4

>>> minOperations(12)
7

>>> minOperations(9)
6

>>> minOperations(0)
0

>>> minOperations(1)
0

PartnerUp: Revolutionizing Project Collaboration

Ajisafe Victor Oluwapelumi — Wed, 21 Jun 2023 21:04:30 +0000

In this blog post, I am excited to present PartnerUp, a web application I developed as part of my portfolio project for the ALX/Holberton Software Engineering Program.

Project Purpose

PartnerUp was created for the purpose of connecting ALX Software Engineering students, enabling them to find suitable project partners effortlessly. By providing a dedicated platform for students to connect and work together, PartnerUp aimed to enhance the overall learning experience and foster a supportive environment.

Timeline

The development process spanned 6 weeks, allowing me to immerse myself in the intricacies of building both the frontend and backend. The timeline provided me with the opportunity to thoroughly plan, design, and implement PartnerUp, ensuring a robust and polished final product.

Target Audience

PartnerUp was specifically designed for ALX Software Engineering students.

Personal Focus

As the sole developer of PartnerUp, I assumed the responsibility of both frontend and backend development. My personal focus revolved around creating a seamless user experience and a robust infrastructure to support the application's functionalities. I dedicated my efforts to ensure that PartnerUp was user-friendly, visually appealing, and responsive across different devices.

Project Inspiration

The inspiration for PartnerUp stems from my own experience as an ALX Software Engineering student. Throughout my journey in the program, I encountered the challenges of finding compatible project partners and witnessed firsthand the impact it had on the success of projects. Motivated by my own experiences and the desire to improve the collaborative experience for ALX students, I set out to create PartnerUp. I wanted to provide a dedicated platform that would empower students to connect with like-minded individuals, form strong project partnerships, and unlock their full potential.

Architecture

I have designed and implemented a robust architecture for PartnerUp that ensures seamless data flow and efficient functionality.

The architecture incorporates the frontend, backend, and database components, enabling smooth communication and interaction between the different layers of the application.

Technology Choices and Justifications

For the frontend development, I harnessed the capabilities of Bootstrap, Jinja, and jQuery to elevate the user experience in PartnerUp. While leveraging these powerful technologies, I ensured that the core web technologies such as HTML5, CSS3, and JavaScript remained at the heart of the project.

With Bootstrap, I effortlessly created responsive and visually appealing user interfaces, allowing PartnerUp to seamlessly adapt to different screen sizes and devices. By integrating Jinja, a templating engine for Python, I streamlined the process of dynamically generating HTML content. Jinja's robust features and syntax provided a flexible and efficient approach to rendering dynamic data, enhancing the overall performance and maintainability of PartnerUp. To enrich the user experience, I harnessed the power of jQuery, a fast and concise JavaScript library.

On the backend, I employed Python as the programming language and utilized the Flask web framework. Flask provided a lightweight and flexible foundation for handling HTTP requests, managing routes, and interacting with the database. Its simplicity allowed for efficient development, and I could focus on building the necessary functionality specific to PartnerUp.

In terms of data storage, I utilized MySQL as the backend database, leveraging its reliability and efficiency for storing and retrieving user information. SQLAlchemy, a Python SQL toolkit, facilitated seamless integration between Python and MySQL, ensuring effective data management and storage.

Key Features Implemented

User Registration and Authentication: PartnerUp enables users to create accounts and authenticate themselves securely. The registration process collects essential user information, which is then stored in the database for future reference. User authentication ensures that only registered users can access and interact with the application's features.
Partner Matching Algorithm: A crucial feature of PartnerUp is its partner matching algorithm. Leveraging the power of PyGithub, the application analyzes user repositories, commits, and coding styles to match ALX students with compatible project partners. This feature streamlines the process of finding suitable partners, enhancing collaboration and project success.
API Routes and Seamless Communication: PartnerUp provides a range of API routes that facilitate seamless communication between the frontend and backend. These routes handle user information submission, retrieval, and partner management, ensuring a smooth flow of data and functionality within the application.

Technical Challenges

As I delved into the development of the partner matching algorithm, I realized that accurately assessing the compatibility of coding periods and identifying relevant repositories would be crucial. I needed to devise an approach that could efficiently analyze and compare large volumes of code while considering various factors. The task at hand was to develop an algorithm that could handle (day/night) coding periods, effectively analyze repositories, and provide accurate partner suggestions based on compatibility. Additionally, I wanted to optimize the algorithm for efficiency and scalability to ensure smooth performance even with a growing user base.

I conducted extensive research on analysis techniques. I integrated Github API to fetch commit history from user repositories. This allowed me to gather information on the user's coding patterns, commit frequency, and commit period. This data served as the basis for evaluating compatibility with potential partners. To provide personalized partner recommendations, I utilized the random library to randomly select three potential partners from the database. This random selection ensured a diverse pool of candidates for consideration. For each selected partner, I compared their commit history with the user's commit data. By analyzing factors such as commit frequency, and coding period, I assessed the compatibility of their coding practices.

Through the combined use of Github API and the random library, I successfully implemented a partner matching algorithm that randomly selected three potential partners, assessed their commit history, and recommended the partner with the closest commit number to the user commit number. This approach ensured a fair selection process while considering the user's commit data and coding style preferences.

Technical Takeaways

Working on both the frontend and backend of the application has significantly broadened my technical skills. I gained a deeper understanding of frontend technologies such as HTML, CSS, and JavaScript, along with backend technologies like Python and database management. This hands-on experience allowed me to strengthen my proficiency in full-stack development and reinforced the importance of having a well-rounded skill set.

About Me

I have a diverse background that combines both design and development. Having previously worked as a designer, I bring a keen eye for aesthetics and a user-centric approach to my projects. I thrive on the intersection of creativity and problem-solving, leveraging my design background to craft meaningful and visually appealing software solutions. I am constantly motivated by the ever-evolving world of engineering and eagerly embrace the challenges and opportunities it presents.

GitHub

Deployed Project

Landing Page

Nginx likes port 80 (a post-mortem)

Ajisafe Victor Oluwapelumi — Fri, 12 May 2023 18:45:36 +0000

The following is the incident report for the Nginx connection failure that occurred on April 3, 2023. We understand this service issue has impacted our valued developers and users, and we apologize to everyone who was affected.

Issue Summary

From 6:30 PM to 7:00 PM WAT, curl requests to our local server on port 80 resulted in connection refused messages. At its peak, the issue affected 100% of traffic to this server. The incident caused a delay in processing critical business operations for some of our users.

Timeline (all West African Time)

6:25 PM: Configuration change is made by Engineer Daniel without peer review
6:29 PM: Nginx is reloaded
6:30 PM: Curl request fails, and issue begins
6:30 PM: Engineer Pelumi notices connection failure
6:50 PM: Engineer Pelumi investigates the issue and identifies the root cause
6:55 PM: Successful configuration change rollback by Engineer Pelumi
6:59 PM: Nginx restarts begin
7:00 PM: 100% of traffic back online

Root Cause and Resolution

At 6:25pm, Engineer Daniel made a configuration change to the nginx configuration file that specifies the ports that the server listens to. The change specified that the default server only listens to requests made on port 8080. This change meant that requests made by our developers and users on port 80 would return connection failure. The configuration change was made without peer review, and this contributed to the issue.

At 6:29pm, nginx was reloaded to apply the configuration changes, and a minute later, curl requests on port 80 returned connection failure. Engineer Pelumi who made the curl request and noticed the connection failure investigated the issue and identified the problem at 6:50pm. Engineer Pelumi rolled back the configuration change and made changes to the configuration file to listen on port 80. The web server was reloaded to apply the changes, and upon another curl request, the connection was restored, and the expected output was returned by the server.

Corrective and Preventative Measures

We have taken the following corrective and preventative measures to ensure that similar incidents do not occur in the future:

We have implemented a peer review process for all configuration changes made to production systems.
We have added additional monitoring and alerting mechanisms to detect configuration issues and notify the appropriate team members in a timely manner.
We have updated our incident response procedures to ensure that all team members are familiar with the steps to take in the event of a configuration issue.

We apologize once again for the inconvenience caused, and we remain committed to providing our users with the best possible service.