Forem: VikthurrDev

So You Want to Pick an Open-Source License? Let’s Talk

VikthurrDev — Fri, 22 Aug 2025 11:28:50 +0000

I still remember the first time I uploaded code to GitHub. Felt like dropping my diary in the middle of a busy café and walking away. Anyone could read it, scribble notes in the margin, or—worst case—claim it as their own. That’s when I learned (the hard way) about open-source licenses. I’d picked “no license,” thinking it meant “free for all.” Nope. In practice, it meant nobody could legally use it. Rookie mistake.

If you’re just getting started in open source—especially here in Africa, where the community is bubbling with fresh talent and energy—understanding licenses isn’t optional. It’s the seatbelt on your road trip. Doesn’t make the journey less fun, but it stops you flying out the window.

Wait, What’s an Open-Source License Anyway?

At its simplest, an open-source license is like a house rule for your code. It says: yes, you can enter, yes, you can rearrange the furniture, but here’s what you owe me in return. Sometimes it’s just credit. Sometimes it’s keeping your changes open too. Think of it as setting boundaries so collaboration doesn’t turn into chaos.

Two Big Buckets: Copyleft vs. Permissive

Here’s where things get spicy. Most licenses fall into two camps:

Copyleft (the “share alike” crew): You can use my code, but if you change it, you must share your changes under the same license. Example? The GNU General Public License (GPL). It’s strict. Some people love that because it keeps the ecosystem fair. Others find it… stifling.
Permissive (the “do what you like” gang): MIT, BSD, Apache. These are chill. They say, “Sure, take my code, build a business around it, sell a product, just keep my name somewhere in the credits.” That’s it.

Quick analogy: Copyleft is like lending someone a recipe and insisting their version stays free for everyone. Permissive is like tossing your recipe into the wind—you don’t mind if it shows up in a restaurant menu tomorrow.

A Story from the Trenches

A friend of mine in Nairobi built a small Python tool for scraping public data. At first, no license. A fintech startup spotted it, improved it, then—surprise—closed it up inside their product. He couldn’t complain because, legally, he hadn’t licensed it. Had he slapped on the GPL, they’d have been forced to release their changes back. Instead? Lesson learned.

On the flip side, I once MIT-licensed a little JavaScript library for charts. A company in Cape Town used it inside a paid app. They sent me a thank-you email months later. Didn’t owe me money. Didn’t need to share improvements. But that project spread farther than I could’ve imagined. So—depends on your goal.

Picking Your First License (Without Losing Your Mind)

Alright, you don’t need a law degree. Here’s the shortcut:

Want your code to stay open forever? Pick GPL or AGPL (if it’s server stuff).
Want the world to use your code however they like? Pick MIT or Apache 2.0 (bonus: Apache covers patents).
Not sure? Honestly, MIT is the safe starter pack. Short, sweet, easy to read.

Pro tip: GitHub makes this super easy. When you create a new repo, it literally asks, “Add a license?” Click the dropdown, pick one. Done.

A Few “But What Ifs…”

What if someone steals my code?
If it’s licensed, they can’t just claim it as theirs. Worst case, you’ve got the law (and community shame) on your side.
What if I don’t want businesses profiting off my work?
Go with copyleft. But keep in mind—some companies may avoid your project entirely because it’s “too open.”
What if I change my mind later?
Tricky. You can re-license future versions, but old releases stay under the old license. That’s why picking upfront is smart.

Why This Matters (Especially Here)

Africa’s dev scene is exploding—check the number of Lagos, Nairobi, Cape Town contributors on GitHub lately. But too many promising projects stall because licensing gets ignored. Imagine you build a tool that could help farmers predict rainfall. A university wants to integrate it, but their lawyers see “no license” and back off. Opportunity lost.

Licenses aren’t just legal fluff. They’re your handshake with the world.

Wrapping It Up Over Coffee

Here’s the thing: open-source licenses aren’t about lawyers in suits. They’re about trust, clarity, and making sure your late-night coding experiments can actually live beyond your laptop. Don’t overthink it. Start simple. Pick MIT if you’re unsure. Pick GPL if you’re a stickler for openness.

And don’t wait until “later.” I’ve seen too many good projects rot in the corner because no one could figure out what they were allowed to do with them.

So—next time you push code, add that license file. It’s five minutes that could save you five years of headaches.

Now, tell me: what’s the first project of yours that’s getting a license today?

The Power of Sports Visibility: Why Southeast Entrepreneurs Should Partner with Football Clubs

VikthurrDev — Sat, 16 Aug 2025 22:28:11 +0000

The Power of Sports in Bridging Business and Culture

Picture a stadium roaring with fans, united by a single goal that sparks joy across communities. In Nigeria’s Southeast, football is more than a sport—it’s a cultural heartbeat that inspires resilience and connection. As a tech expert, I’ve witnessed how technology has transformed local clubs into global brands, extending their reach from fields to fans’ smartphones. For Southeast entrepreneurs, this is a unique opportunity to grow your business by tapping into the passion for football. Partnering with clubs like Rangers International can elevate your brand and forge deep community ties. Let’s explore why this matters and how you can act.

The Magic of Sports Visibility

Sports visibility is about leveraging a club’s influence to boost your brand. Through sponsorships, athlete endorsements, and events, businesses gain access to a loyal, engaged audience. In the Southeast, where football is a way of life, clubs like Rangers International hold immense sway. Technology has amplified this reach, with fans following matches, sharing highlights, and engaging with brands on platforms like X and Instagram. A single sponsored post or a player wearing your logo can reach thousands instantly, offering exposure that traditional ads can’t match. For entrepreneurs, this is a chance to connect with a passionate community in a meaningful way.

Rangers International: A Symbol of Resilience and Unity

Rangers International, based in Enugu, is more than a football club—it’s a symbol of hope with deep roots in the Southeast. Founded in 1970 after the Nigerian Civil War, Rangers emerged as a beacon for the Igbo community. In the post-war years, their victories in national tournaments lifted spirits and fostered national healing. Defeating the Nigerian Army team 2-1 in a historic match, Rangers proved that resilience could triumph over adversity, embodying their motto: “Never Say Die.” This legacy makes Rangers a powerful partner for entrepreneurs seeking authentic connections with the Southeast’s vibrant culture.

Rangers International Football Club, Biafran Army versus Nigerian Army

Case Study: Afrinvest and Rangers’ Winning Partnership

A shining example of sports visibility in action is the partnership between Rangers International and Afrinvest (West Africa) Limited, a leading financial services firm. In October 2023, Afrinvest signed a three-year jersey sponsorship deal worth N50 million per season, with clauses for renewal. The agreement, initiated six years earlier under Rangers’ former team manager Davison Owumi, aimed to professionalize the club and attract business investment.
afriinvest image

The results were remarkable. By June 2024, Rangers won the Nigeria Premier Football League (NPFL) for the eighth time, earning a spot in the 2024/25 CAF Champions League. Afrinvest’s logo, emblazoned on Rangers’ jerseys during victory parades, gained massive visibility across the Southeast and beyond, amplified by social media and fan-generated content. Dr. Ike Chioke, Afrinvest’s Group Managing Director and an Enugu native, emphasized that the partnership was about more than branding—it was about uplifting talent and inspiring hope in a region facing economic challenges. He noted, “A victory for Rangers is a victory for all of us, victory for our human capacity to succeed.”

AFRINVEST COMMITS TO FURTHER PARTNERSHIP WITH RANGERS

This partnership gave Afrinvest a strong local appeal in the Southeast. By aligning with Rangers, a club synonymous with Igbo resilience, Afrinvest connected authentically with fans, positioning itself as a brand that supports community pride and excellence. The partnership’s success, celebrated at events attended by Enugu State officials, showcased how businesses can gain trust and visibility through sports.

Why This Connection Matters for Entrepreneurs

For Southeast entrepreneurs, partnering with Rangers offers a chance to build trust and relevance. The club’s history resonates with fans who see it as a symbol of perseverance. Sponsoring a match or collaborating with players aligns your brand with this legacy, creating emotional connections. Technology makes this accessible—social media posts or live streams can amplify your message to fans’ phones instantly. For instance, a local startup could sponsor a matchday event, gaining exposure through Rangers’ digital platforms. Small businesses can start with affordable options like social media shoutouts or branded giveaways, making an impact without breaking the bank. The Afrinvest case shows how such partnerships deliver tangible results, enhancing local appeal and credibility.

The Southeast Market: A Growing Opportunity

The Southeast’s market is a goldmine for entrepreneurs. With over 20 million people across five states (Abia, Anambra, Ebonyi, Enugu, and Imo), the region is an economic hub driven by cities like Onitsha and Aba. Nigeria’s sports market, fueled by football, is growing, with technology boosting fan engagement. Over 80% of Nigerians own smartphones, meaning your brand can reach this market instantly through a club’s digital channels. Partnering with Rangers taps into this vibrant, tech-savvy audience, connecting with consumers eager for innovative products.

Rangers International FC visit Billionaire Entrepreneur, Blord Group

These images capture a recent visit by Rangers International Football Club to a leading Southeast entrepreneur, Mr Linus William, CEO of Blord Group, sparking discussions on partnerships like youth academies and branded campaigns. Such engagements show how Rangers actively connect with the business community, offering entrepreneurs a platform to gain visibility and trust.

The Afrinvest partnership proves that working with Rangers delivers results, from local appeal to national recognition. Don’t wait—reach out to Rangers International today to score big in the Southeast.

Tutorial to run a Gensyn Testnet Node on Quickpod

VikthurrDev — Wed, 06 Aug 2025 12:34:30 +0000

Here's a step-by-step guide to run a Gensyn RL Swarm Testnet node:

Step 1: Prepare Your Environment

Rent a Cloud GPU

QuickPod
- Sign up at QuickPod
- Deposit crypto, rent a CUDA 12.4 GPU (e.g., RTX 4090, RTX 3090)
- Connect via web terminal or SSH

Step 2: Install Dependencies

Run these commands in your terminal (remove sudo when using QuickPod):

Update System

apt update && apt upgrade -y

Install Basic Tools

apt install screen curl iptables build-essential git wget lz4 jq make gcc nano automake autoconf tmux htop nvme-cli libgbm1 pkg-config libssl-dev libleveldb-dev tar clang bsdmainutils ncdu unzip libleveldb-dev -y

Install Python

apt install python3 python3-pip python3-venv python3-dev -y

Install Node.js

 curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
 apt install -y nodejs
 npm install -g yarn

Install Yarn

 curl -o- -L https://yarnpkg.com/install.sh | bash
 export PATH="$HOME/.yarn/bin:$HOME/.config/yarn/global/node_modules/.bin:$PATH"
 source ~/.bashrc

Clone the GitHub repository

git clone https://github.com/gensyn-ai/rl-swarm/

Move into the cloned repository directory

cd rl-swarm

Open a virtual terminal that runs in the background

apt install tmux  

tmux new -s gensyn_node

Install swarm

 python3 -m venv .venv

 . .venv/bin/activate

Start gensyn node

 ./run_rl_swarm.sh

3. Log in to your node

1. Wait for User Data Creation

Action: Monitor your logs until you see: Waiting for userData.json to be created...
Note: This confirms the node is ready for login.

2. Access the Login Page

GPU Cloud/VPS Users

Open a new terminal.
Install localtunnel:

   npm install -g localtunnel

Get your password (VPS IP):

   curl https://loca.lt/mytunnelpassword

Generate a public URL:

   lt --port 3000

Access the URL in your browser and enter the password (your VPS IP).

3. Choose your Login

Action: Use your preferred login method (e.g., GitHub, email).
What Happens Next: After login, the terminal automatically starts the installation process.

4. Complete Setup Prompts

Hugging Face Hub Upload:

Prompt:

 Would you like to push models you train to the Hugging Face Hub? [y/N]

a. - Testnet Users: Press N (no upload).

Select a Model:

Prompt:

 Enter the name of the model (repo/name) or [Enter] for default:

5. Verify Node Operation

Action: Check the terminal for a message like: Hello, [your node name] (e.g., "whistling hulking armadillo").
Tip: Use CTRL+SHIFT+F to search for "Hello" in logs.

6. Detach from the termux terminal

Press Ctrl + B, then release and press D (Detach).

7. Backup your secret identity

Move into your cloned repository directory, e.g, rl-swarm.

Copy the swarm.pem file into your computer using the SCP protocol.

scp -P {PORT} {USER}@{IP ADDRESS}:{REMOTE PATH TO FILE} {PATH TO WHERE YOU WANT TO SAVE THE FILE IN YOUR COMPUTER}

Create a folder named backup.

e.g scp -P 41200 36****f-***-43c0-a339-038c8***234@74.133. .***.***.248:/***/****/swarm.pem /home/****/backup

When Web3 + Machine Learning + Cloud Computing collide (Simplified).

VikthurrDev — Wed, 06 Aug 2025 08:27:09 +0000

🧩 What is Gensyn AI?

Gensyn AI is basically a decentralized AI training network.

Instead of all AI training being done on giant, expensive, centralized servers owned by a few companies, Gensyn lets anyone with computing power contribute and get rewarded.

Think of it like:

Uber for AI compute 🚗💻 — you bring your “car” (GPU or CPU), they match you with AI workloads, and you earn for your contribution.

🌍 Why Does It Exist?

AI training is:

Expensive — high-end GPUs are rare and costly.
Centralized — a handful of tech giants control most compute.
Underutilized — many GPUs sit idle (e.g., gamers, universities, labs).

Gensyn’s goal is to:

Spread AI training across the world (decentralization).
Make it cheaper for researchers and developers.
Let regular people earn by renting out their unused computing power.

⚙️ How It Works (Simplified)

People request AI training jobs on the network.
The network splits the work into smaller pieces.
Nodes do the training tasks.
Gensyn verifies you did the work correctly.
You get rewarded (currently testnet, but mainnet will have crypto rewards).

🤖 What’s RL‑Swarm?

RL‑Swarm is the node software you run to connect to Gensyn’s network.

When you run RL‑Swarm:

You join the swarm of nodes.
You receive AI workloads.
You can see your performance in a web dashboard.

It’s like installing the “driver app” for your GPU so it can work on the Gensyn network.

💡 Current Status (as of now)

Running in testnet — rewards are for testing/tracking only, but mainnet will pay.
Supports CPU & GPU — but GPU is much faster and preferred.
Community-driven — many people run it from home, on cloud services like QuickPod, or even on idle gaming rigs.

🧠 In Short

Gensyn AI is building a global, shared AI supercomputer

powered by people’s GPUs and CPUs, rewarding them for training AI models.

To win rewards, check out this tutorial for setting up a node

Designing a webhook service: A practical guide to event-driven architecture.

VikthurrDev — Mon, 28 Oct 2024 09:32:12 +0000

Introduction

Many organizations depend on third-party vendors for services e.g payment processing and merchandise reselling. While these partnerships can enhance efficiency but it comes with challenges such as how to keep track of vendor performance and transparency.
One effective way to tackle these challenges is through an event-driven architecture (EDA).

The Problem

As my organisation grows in revenue and size. Their third party vendors network also expands. I was tasked with providing a solution that monitors all activities in our third parties system to improve transparency and performance review. Communicating key metric like "sales per month" visually is compulsory. A dashboard that visualize these data is a key component of the solution.

Event Driven Architecture

An event-driven architecture focuses on producing, detecting, and responding to events in real time.

What is a Webhook?

A webhook is a simple way for one system to send data to another when a specific event occurs. For example, when a payment is processed, a webhook can instantly notify your system by sending relevant data. This eliminates the need for constant checks on the vendor’s system, providing real-time updates.

Advantages of Webhooks

Instant Updates: Webhooks provide immediate notifications, keeping your organization informed.
Resource Efficiency: By avoiding constant polling, webhooks save server resources and bandwidth.
Customization: You can set up your own endpoints and tailor the data to your needs.
Ease of Use: Webhooks are straightforward to implement with minimal changes to existing systems.

Functional Requirements

Accept Executed API Requests: The webhook service should be capable of receiving incoming API calls from third-party systems.
Execute Corresponding Events: Upon receiving a request, the service must trigger the appropriate events based on the webhook data.
Persist Events and Results: The service should store both the event data and the results of processed events in a database for future reference and analysis.

Non-Functional Requirements

High Availability: The webhook service must be designed for minimal downtime, ensuring it is consistently accessible.
At Least Once Delivery: Every event must be delivered at least once, even in the face of system failures.
Idempotency: The system should handle duplicate event deliveries gracefully, ensuring that processing the same event multiple times does not lead to inconsistent states.

Traditional Architecture Flaws

figure 1.0 A simple webhook implementation

In a traditional setup, the request handler directly processes incoming requests, executes the necessary business logic, and saves results to the database. While this method may seem straightforward, it has several significant drawbacks:

Tight Coupling: Request handling and business logic are closely integrated, making it hard to scale components independently.
Single Point of Failure: If the request handler fails, the entire system may become unresponsive.
Lack of Load Buffering: High traffic periods can overwhelm the system, leading to potential failures.
No Built-in Retry Mechanism: If an operation fails, there is often no automated way to retry processing the event.

Solution: Integrating a Message Queue

figure 1.1 An resilient webhook

To address these challenges, adding a message queue into the architecture can significantly enhance the webhook service's performance and reliability. Here’s how this integration works:

Decoupling: Instead of directly processing events, the request handler sends messages to a queue. This decouples the request handling from event processing, allowing for independent scaling.
Load Buffering: The message queue acts as a buffer, holding incoming requests during peak traffic, ensuring the system can handle bursts of activity without failure.
Scalability: Additional consumers can be added to process messages from the queue, enabling horizontal scaling as demand increases.
Failure Recovery: If an event fails to process, the message can be retried automatically, ensuring at least once delivery.

Benefits of Message Queue Integration

Improved Reliability: A message queue can handle traffic spikes gracefully, preventing service outages.
Enhanced Flexibility: Components can evolve independently, simplifying maintenance and upgrades.
Efficient Resource Utilization: Offloading processing to the queue keeps the request handler responsive, enhancing overall performance.

Data flow of a resilient webhook

figure 1.2 data flow of resilient webhook

Handling Failure

In a robust event-driven architecture, handling failures effectively is crucial to maintaining system resilience.

1. Webhook Trigger and API Request

When an event occurs in the third-party system, the webhook sends an API request to your service with the event data.

2. Message Queue Enqueueing

Upon receiving the request, the webhook at enqueue the message into the message queue:

Success Scenario: If the message is successfully enqueued, the system returns a 200 response to the user, indicating that the event has been received and will be processed.
Failure Scenario: If the message fails to enqueue (for instance, due to a queue service outage), the system responds with an appropriate error code (e.g., 500 Internal Server Error) instead of a 200. This informs the user that the event was not successfully processed.

3. Event Processing from the Queue

Once the message is in the queue, a consumer service will pick it up for processing:

Data Persistence Check: During processing, the consumer attempts to save the event data to the database.
Success Scenario: If the data is successfully saved, the event can be dequeued, and processing is considered complete.
Failure Scenario: If the data fails to save (due to database issues, for example):
- The event remains in the queue and is not dequeued.
- If the maximum retry attempts are reached without success, tan alert can be generated for system administrators.

4. Response Handling

To summarize the response handling:

If the event is not enqueued, the user receives a 500 error response.
If the event is enqueued but the data fails to save to the database, the event remains in the queue, and no acknowledgment of success is provided until the data is successfully saved to the database .

Handling Security with HMAC

What is HMAC?

HMAC (Hash-based Message Authentication Code) is a method that uses a shared secret key to create a unique hash value for a message. This ensures both integrity (the message hasn't been altered) and authenticity (the message is from a trusted source).

Implementation Steps:

Shared Secret Generation: Establish a confidential shared secret between your system and the third-party service.
HMAC Signature Creation: When an event occurs, the vendor generates an HMAC using the shared secret and the payload.
Sending the Webhook: The service sends the payload along with the HMAC in an HTTP header (e.g., X-Hub-Signature).
Signature Verification: Your system recalculates the HMAC for the received payload and compares it with the received signature to ensure they match.

Overview of Services

Database Service: Stores webhook events.
Request Handler Service: Receives incoming webhook requests and enqueues messages to RabbitMQ.
Queue Broker: RabbitMQ to manage the message queue.
Consumer Service: Processes messages from the queue and interacts with the database.

Step 1: Create the Request Handler Service

//server.js
const express = require('express');
const amqp = require('amqplib');
const bodyParser = require('body-parser');
const HMAC = require('./verfiy-hmac'); 
require('dotenv').config();

const app = express();
app.use(bodyParser.json());

const RABBITMQ_URL = process.env.QUEUE_URL;

app.post('/webhook', async (req, res) => {
    const payload = req.body;


    if (!HMAC.verify(payload, req.headers['x-hub-signature'])) {
        console.log(req.headers['x-hub-signature'],"hdhdhhd")
        return res.status(403).send('Unauthorized');
    }

    try {
        const connection = await amqp.connect(RABBITMQ_URL);
        const channel = await connection.createChannel();
        await channel.assertQueue('webhook_queue');
        channel.sendToQueue('webhook_queue', Buffer.from(JSON.stringify(payload)));
        res.status(200).send('Event received');
    } catch (error) {
        console.error(error);
        res.status(500).send('Internal Server Error');
    }
});

app.listen(process.env.PORT, () => {
    console.log(Request Handler Service running on port ${process.env.PORT} );
});

Step 2: Create HMAC Verification

// verify-hmac.js
const crypto = require('crypto');
require('dotenv').config();
const SECRET = process.env.PW; 

module.exports.verify = (payload, signature) => {
    const hmac = crypto.createHmac('sha256', SECRET);
    hmac.update(JSON.stringify(payload));
    const calculatedSignature = hmac.digest('hex');
    return calculatedSignature === signature;
};

step 4: create your consumer service

const amqp = require('amqplib');
const mysql = require('mysql');
require("dotenv").config();

const RABBITMQ_URL = process.env.QUEUE_URL;

const db = mysql.createConnection({
    host: "db",
    user: "root",
    password:"rootpassword",
    database: "events_db",
    port:3306
});

db.connect((err) => {
    if (err) {
        console.error("Error connecting to MySQL:", err);
        return;
    }
    console.log("Connected to MySQL database.");
});

async function consume() {
    const connection = await amqp.connect(process.env.QUEUE_URL);
    const channel = await connection.createChannel();
    await channel.assertQueue('webhook_queue');

    channel.consume('webhook_queue', async (msg) => {
        if (msg !== null) {
            const payload = JSON.parse(msg.content.toString());
            db.query("INSERT INTO events (payload) VALUES (?)", [JSON.stringify(payload)], (err) => {
                if (err) {
                    console.error("Error saving to database:", err);
                } else {
                    console.log("Saved to database:", payload);
                }
            });
            channel.ack(msg);
        }
    });
}

consume().catch(console.error);

step 5: create relational database

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: events_db
    ports:
      - "3306:3306"
    volumes:
      - /var/lib/mysql
    networks:
      webhook_network:
        ipv4_address: 172.20.0.20

step 6: create message queue

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "15672:15672"
      - "5672:5672"
    networks:
      webhook_network:
        ipv4_address: 172.20.0.10

//docker-compose.yml
version: '3.8'

services:
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "15672:15672"
      - "5672:5672"
    networks:
      webhook_network:
        ipv4_address: 172.20.0.10

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: events_db
    ports:
      - "3306:3306"
    volumes:
      - /var/lib/mysql
    networks:
      webhook_network:
        ipv4_address: 172.20.0.20

  request-handler:
    build:
      context: ./requestHandler
      dockerfile: Dockerfile
    depends_on:
      - rabbitmq
    ports:
      - "3000:3000"
    networks:
      webhook_network:
        ipv4_address: 172.20.0.30

  consumer:
    build:
      context: ./consumer
      dockerfile: Dockerfile
    volumes:
      - ./app
    depends_on:
      - rabbitmq
      - db
    networks:
      webhook_network:
        ipv4_address: 172.20.0.40

networks:
  webhook_network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

volumes:
  db-data:

After running docker-compose up, you’ll have four services up and running: RabbitMQ, MySQL, a Consumer service, and a Request Handler service. Each of these services is assigned a static IP address to ensure stable communication within your application.

You can find the code for this setup on my github.

If you found this guide helpful, please give it a like! If I receive 10 likes, I’ll create a detailed tutorial video that walks you through the entire process.