Forem: Eddie Gulay

Under-presentation of Swahili in AI tasks

Eddie Gulay — Sat, 10 Jan 2026 19:32:14 +0000

the cover image is also underpresented!

Swahili is significantly underrepresented in AI research and applications, especially compared to languages like English, Mandarin, Spanish, or even French. A few key points highlight this gap:

Data Scarcity: Large-scale datasets in Swahili are limited. Most NLP models rely on massive text corpora to learn patterns, but Swahili content online is comparatively small, fragmented, or noisy.
Limited Pretrained Models: While there are some multilingual models like mBERT or XLM-R, they underperform on Swahili because the language is a small fraction of their training data. Truly high-performing, Swahili-specific models are rare.
Low Research Focus: Academic and industry research in NLP and speech processing often overlooks Swahili. Few papers focus on tasks like sentiment analysis, machine translation, or speech recognition for Swahili.
Speech and Multimodal Gaps: Swahili speech datasets, handwritten text, and multimodal datasets (images with Swahili captions, videos, etc.) are almost non-existent. This makes building voice assistants, OCR, or image captioning models in Swahili extremely challenging.
Impact on Applications: This underrepresentation affects practical AI applications—chatbots, translation services, digital assistants, and educational tools often fail to work well for Swahili speakers.

Aand.. Here's a detailed table of AI and ML tasks where Swahili is underrepresented, organized by category. I’ve included the task, current state for Swahili, and potential impact if addressed. This should give a clear sense of both gaps and opportunities.

Category	AI Task	Current State for Swahili	Potential Impact if Developed
Natural Language Processing (NLP)	Language Modeling	Few large-scale Swahili corpora; multilingual models underperform	Better text generation, predictive typing, writing aids
	Text Classification	Very limited labeled datasets for topics, sentiment, or spam detection	Improved moderation, content filtering, sentiment analysis
	Sentiment Analysis	Almost no high-quality annotated datasets	Social media monitoring, brand analysis, public opinion insights
	Named Entity Recognition (NER)	Few datasets; existing NER models often fail on Swahili text	Improved information extraction for news, legal, and healthcare texts
	Part-of-Speech Tagging	Sparse corpora; rules-based systems dominate	Better grammar analysis, parsing, and downstream NLP tasks
	Machine Translation	Limited parallel corpora; Google Translate quality varies	Accurate translation for education, business, and government documents
	Summarization	Almost nonexistent datasets or pretrained models	Automated content summarization for news, legal, and academic texts
	Question Answering	Very few datasets; models trained on English fail on Swahili	AI assistants, educational tools, customer support systems
	Semantic Search / Retrieval	Limited indexing and embeddings in Swahili	Efficient document retrieval, knowledge bases, and search engines
Speech & Audio	Automatic Speech Recognition (ASR)	Few large-scale Swahili audio datasets	Voice assistants, dictation tools, transcription services
	Text-to-Speech (TTS)	Limited high-quality Swahili voice models	Assistive tech, IVR systems, audiobooks
	Speech Translation	Almost nonexistent	Real-time communication across languages
	Speaker Diarization	Rare for Swahili	Meeting transcription, call center analysis
Multimodal AI	Image Captioning	No significant Swahili-labeled image datasets	Accessibility tools, educational resources, social media tagging
	OCR (Optical Character Recognition)	Some work on printed Swahili; handwritten datasets very rare	Digitalizing documents, preserving literature and historical texts
	Video Understanding	No datasets with Swahili captions or narration	Subtitling, content indexing, AI tutors
Dialog & Conversational AI	Chatbots	Very few Swahili-trained models	Customer support, education, e-government services
	Dialogue Summarization	Almost no datasets	Meeting notes, conversational analytics
	Intent Recognition	Few datasets	Better automation for local businesses
Recommendation Systems	Content Recommendation	Sparse data, especially for Swahili media	Localized content discovery (books, music, news)
Information Extraction	Knowledge Graph Construction	Rare Swahili corpora for entity linking	Structured knowledge bases for research, government, and business
Education & Literacy AI	Reading Assistance	Limited AI tutors or literacy tools	Supporting Swahili literacy, personalized education
	Language Learning Tools	Very few AI apps teaching Swahili	Global Swahili learning adoption
Healthcare AI	Clinical Text Mining	Almost nonexistent Swahili medical datasets	Medical record processing, health insights
	Speech-based Diagnostics	No datasets	Remote healthcare, voice-based symptom screening
Finance & Business	Sentiment/Trend Analysis in Swahili	Minimal coverage	Market intelligence, consumer behavior analytics
	Automated Form Processing	Limited NLP for Swahili documents	Banking, insurance, government services
Legal & Governance	Legal Document Analysis	Rare datasets	Contract review, policy extraction, case law research
	Automated Compliance Checks	Very limited AI tools	Regulatory monitoring, e-government services
Social Media & Content Moderation	Hate Speech / Misinformation Detection	Almost no labeled datasets	Safer online communities, responsible platform governance
	Social Analytics	Sparse tools	Monitoring trends, public opinion, emergency response
Cultural & Historical Preservation	Digitization of Literature	Limited Swahili text corpora	Preserving oral history, books, and cultural materials
	Oral History Transcription	Very few annotated datasets	Archiving traditional storytelling and interviews

This table already highlights 40+ tasks where Swahili is significantly underrepresented. Most of these gaps are not due to technical impossibility—they’re primarily data scarcity and research neglect. Addressing them would have high societal, educational, and economic impact, especially in East Africa where Swahili is widely spoken.

So i am going to leave these here until i get implementations of them.

PostgreSQL Backup the quick Way

Eddie Gulay — Sat, 04 Oct 2025 19:18:54 +0000

PostgreSQL is one of the most reliable open-source databases, but backups are often handled in overly complex ways — involving filesystem snapshots, replication configurations, or manual tar archives.
If you just need a clean, portable, and consistent backup of all your databases, PostgreSQL already includes a simple tool for that: pg_dumpall.

This post shows how to create a full backup of your PostgreSQL server in one line — and how to move it safely to your local machine.

Why “Logical” Backups Are Enough

There are two kinds of PostgreSQL backups:

Physical backups — copy all data files on disk; good for point-in-time recovery but heavy and less portable.
Logical backups — dump all SQL definitions and data; lighter, portable, and perfect for everyday snapshots or migrations.

If your goal is to have a restorable .sql file containing every database, user, and permission, a logical backup is the right choice.

Step 1 — Create the Backup

Run this command directly on your server:

sudo -u postgres pg_dumpall > /tmp/october_4_2025_backup.sql

This command:

Connects as the postgres superuser
Dumps all databases, roles, and grants
Produces one plain-text SQL file ready for restoration

You can name the file however you prefer — for example, include the date:

/tmp/october_4_2025_backup.sql

Step 2 — Verify the Backup

Check that the backup file exists and has a reasonable size:

ls -lh /tmp/october_4_2025_backup.sql

Optional: look at the first few lines:

head /tmp/october_4_2025_backup.sql

Step 3 — Copy the Backup to Your Local Machine

Use scp (secure copy) to transfer the backup:

scp user@your_server_ip:/tmp/october_4_2025_backup.sql ~/Downloads/

Replace:

user → your SSH username
your_server_ip → your server’s IP address

Now your backup is safely stored on your local machine.

Optional — Compress the Backup

If the database is large:

gzip /tmp/october_4_2025_backup.sql
scp user@your_server_ip:/tmp/october_4_2025_backup.sql.gz ~/Downloads/

This typically reduces file size by 70–90%.

Step 4 — Restore the Backup (When Needed)

To restore everything to a new PostgreSQL instance:

psql -U postgres -f october_4_2025_backup.sql

If compressed:

gunzip -c october_4_2025_backup.sql.gz | psql -U postgres

This recreates all databases, roles, and data as they were during the backup.

Automation Tip

To schedule a daily or weekly backup automatically, create a cron job:

sudo crontab -u postgres -e

Add this line:

0 2 * * * /usr/bin/pg_dumpall > /var/backups/pg_backup_$(date +\%F).sql

That takes a nightly snapshot at 2 a.m. — hands-free.

Setting up SSH for GitHub on Linux Mint

Eddie Gulay — Sun, 28 Sep 2025 21:17:54 +0000

When working with GitHub, cloning repositories over SSH is faster and more secure than using HTTPS. If you’re setting it up for the first time, it can feel like a maze of commands and errors. This guide walks you through generating an SSH key, adding it to GitHub, and configuring your machine to authenticate seamlessly.

1. Check for Existing SSH Keys

First, check if you already have SSH keys on your system:

ls -al ~/.ssh

If you see files like id_ed25519.pub or id_rsa.pub, you already have keys. Otherwise, continue to the next step.

2. Generate a New SSH Key

Generate a new Ed25519 key pair (recommended):

ssh-keygen -t ed25519 -C "your_email@example.com"

Replace your_email@example.com with the email tied to your GitHub account.
When prompted for a file name, press Enter to use the default (~/.ssh/id_ed25519), or specify your own (e.g., mygithubkey).

If you chose a custom name, move the files into ~/.ssh:

mv ~/path/to/mygithubkey ~/.ssh/
mv ~/path/to/mygithubkey.pub ~/.ssh/

Set the correct permissions:

chmod 600 ~/.ssh/mygithubkey
chmod 644 ~/.ssh/mygithubkey.pub

3. Start the SSH Agent and Add the Key

Start the SSH agent:

eval "$(ssh-agent -s)"

Add your private key:

ssh-add ~/.ssh/mygithubkey

Verify it was added:

ssh-add -l

4. Add the Public Key to GitHub

Display your public key:

cat ~/.ssh/mygithubkey.pub

It will look something like this:

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAEXAMPLEKEYSTRING user@example.com

Copy the entire line, then go to:
GitHub → Settings → SSH and GPG keys → New SSH key.

Give it a title (e.g., Linux Mint Laptop).
Paste the key.
Save.

5. Test the Connection

Run:

ssh -T git@github.com

If everything is set up correctly, you’ll see:

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

6. Clone Repositories with SSH

Now you can clone repositories using the SSH URL:

git clone git@github.com:your-username/your-repo.git

7. Optional: Configure SSH for Multiple Keys

If you use multiple keys, configure SSH to always use the right one for GitHub. Edit your config:

nano ~/.ssh/config

Add:

Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/mygithubkey

Save and exit. Now GitHub will always use that key automatically.

How to Transform Jupyter Notebook into a Maintainable AI Project

Eddie Gulay — Fri, 16 May 2025 20:09:51 +0000

A Python package named modinit that facilitates the rapid scaffolding of AI model training repositories with a standardized, best-practice structure. This tool is designed to save time and ensure consistency across machine learning projects.

Problem, Transitioning from Notebooks to Production Ready Code

In machine learning and AI development, it's common to begin with Jupyter notebooks for experimentation and prototyping. However, as projects mature, there's a need to transition this code into a more structured, maintainable, and deployable format. This transition poses several

challenges:

Code Organization: Notebooks often contain a mix of data processing, model definition, training loops, and evaluation code, making it hard to modularize and reuse components.
Version Control: Tracking changes in notebooks is less straightforward compared to plain .py files, complicating collaboration and versioning.
Reusability and Testing: Functions and classes defined in notebooks are not easily reusable across different projects or testable in isolation.
Deployment: Deploying models trained in notebooks to production environments requires refactoring code into scripts or packages, which can be time-consuming and error-prone.

Solution, Structured Project Template

To address these challenges, adopting a standardized project structure is essential. Such a structure separates concerns, promotes code reusability, and aligns with best practices in software development. Here's a suggested layout:

your_project/
│
├── notebooks/            # Jupyter notebooks for experimentation
│   └── prototype.ipynb
│
├── src/                  # Core Python package
│   ├── __init__.py
│   ├── data.py           # Data processing functions
│   ├── model.py          # Model architecture definitions
│   ├── train.py          # Training routines
│   ├── evaluate.py       # Evaluation metrics and logic
│   └── utils.py          # Utility functions (e.g., decoding, accuracy calculations)
│
├── main.py               # Entry point for training/testing/inference
├── config.yaml           # Configuration file for hyperparameters and settings
├── requirements.txt      # List of dependencies
└── README.md             # Project overview and instructions

This structure offers several benefits:

Modularity: Each component of the project (data processing, model definition, training, evaluation) is encapsulated in its own module, enhancing readability and maintainability.
Scalability: As the project grows, this structure accommodates the addition of new features, models, or datasets without significant reorganization.
Collaboration: Clear separation of concerns allows team members to work on different parts of the project simultaneously with minimal conflicts.
Deployment: Having a main.py as the entry point simplifies the process of deploying the model for inference or integrating it into larger systems.

Introducing `modinit`: Automating the Setup

To streamline the creation of such a structured project, your modinit package automates the scaffolding process. By running a simple command, developers can generate a project with the aforementioned layout, complete with template files and docstrings. This automation reduces setup time and ensures adherence to best practices from the outset.

Next Steps

To get started with modinit, you can install it via pip:

pip install modinit

Then, initialize a new project:

modinit create my_new_project

This command will generate a new directory my_new_project with the standardized structure, allowing you to focus on developing your AI models without worrying about project organization.

Fed Up with Docker? Here, Uninstall It Completely (No Coming Back!)

Eddie Gulay — Wed, 26 Feb 2025 12:01:44 +0000

Docker is a fantastic tool... until it isn’t. Maybe you're tired of mysterious container issues, endless rebuilds, or "it works on my machine" nightmares. Whatever the reason, you’ve reached the breaking point and decided to part ways with Docker. You don’t just want it gone — you want it obliterated from your system with no trace left behind.

If that sounds like you, this guide is your salvation. We’re not going to sugarcoat it. This post is about getting rid of Docker once and for all. Let’s dive in.

Why Uninstall Docker?

Bloated disk usage from dangling images and unused volumes.
Frequent conflicts and compatibility issues.
Frustration with complex configurations.
Seeking alternatives that better fit your workflow.

Whatever the reason, you're here to uninstall Docker, so let's not waste time.

Step 1: Stop and Remove Running Containers

Before you rip Docker out, you need to stop any running containers:

docker ps -q | xargs -r docker stop

Want to nuke all containers, images, and volumes?

docker system prune -a --volumes --force

Warning: This wipes out all your Docker data. If you're sure you never want to see it again, go for it.

Step 2: Uninstall Docker (Ubuntu/Linux)

Docker doesn’t just live in one place. It scatters components all over your system. Here’s how to find them all and remove them.

Purge Docker Packages

Remove Docker and its related components:

sudo apt-get purge -y docker-engine docker docker.io docker-ce docker-ce-cli containerd runc

Step 3: Clean Up Residual Files

Docker leaves behind configuration files and volumes. Nuke them with:

sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd
sudo rm -rf /etc/docker
sudo rm -rf ~/.docker

This ensures no leftover Docker data is hiding in your system.

Step 4: Remove Docker Repositories and Keys

Get rid of Docker’s repository entries and GPG keys:

sudo rm /etc/apt/sources.list.d/docker.list
sudo rm -rf /etc/apt/keyrings/docker.gpg

Remove the keyrings directory if it was created just for Docker:

sudo rm -rf /etc/apt/keyrings/

Step 5: Autoremove and Clean Packages

Run these commands to clean any orphaned packages:

sudo apt-get autoremove -y --purge docker docker-ce docker-ce-cli
sudo apt-get clean

Step 6: Verify Docker is Gone

Let’s make sure Docker is truly out of your life:

docker --version  # Should return 'command not found'
docker-compose --version  # Should also return 'command not found'

If both commands fail, congratulations! Docker is history.

Bonus: Remove Docker Groups and Users (Optional)

To remove the Docker group:

sudo groupdel docker

If you had a dedicated Docker user (rare case), you can delete it:

sudo userdel docker

Step 7: Reboot (Optional but Recommended)

Sometimes services linger in memory. Reboot to make sure everything is cleared:

sudo reboot

While sipping monster energy ...

Docker had its moment, but you’re done. With the steps above, you’ve not only uninstalled Docker — you’ve wiped every trace of it from your machine. No coming back. No lingering configs. No haunted volumes.

Thinking of alternatives? Check out tools like Podman, Minikube, or Vagrant for container-free virtualization. Or maybe take a break from containerization altogether. You’ve earned it.

Goodbye, Docker. It was... something.

TL;DR:

Stop and remove containers: docker system prune -a --volumes --force
Purge Docker: sudo apt-get purge -y docker*
Remove Docker files: sudo rm -rf /var/lib/docker /etc/docker ~/.docker
Clean up packages: sudo apt-get autoremove -y --purge docker*
Verify: docker --version (should fail)
Reboot: sudo reboot

That’s it. Docker is out. No regrets.

Writing clear, concise, and meaningful commit messages is key to maintaining a well-documented Git history. Here’s a practical guide to writing great Git commit messages.

Eddie Gulay — Wed, 29 Jan 2025 22:31:52 +0000

Writing clear, concise, and meaningful commit messages for a well-documented Git history

Eddie Gulay ・ Jan 29

#github #commitmessage #git

Writing clear, concise, and meaningful commit messages for a well-documented Git history

Eddie Gulay — Wed, 29 Jan 2025 22:28:40 +0000

Let’s Talk About Writing Commit Messages That Actually Make Sense

Commit messages might seem like a small thing when you’re knee-deep in code, but they’re like little breadcrumbs you leave for yourself and your team. A good one can save you from scratching your head weeks later, wondering what on earth you were doing. So, how do you write one that’s clear and helpful without feeling like a chore? It’s simpler than you might think.

Start with a type—a quick label that says what kind of change you’re making. Then add a short summary, and if it’s a bigger change, toss in a few extra details. That’s it! Let’s break it down a bit.

Kick Things Off with a Commit Type

Think of the commit type as a way to sort your changes into buckets. Here’s a quick rundown of the common ones:

Type	What It Means	Example
feat	Adding something new	`feat: add date filtering for GitHub activity`
fix	Squashing a bug	`fix: handle API failure when GitHub is down`
refactor	Tidying up code without changing what it does	`refactor: optimize API response formatting`
docs	Updating documentation	`docs: update README with API usage guide`
chore	Little maintenance tasks	`chore: add .gitignore and remove logs`
style	Just making things look prettier	`style: format code with Black`
test	Adding or tweaking tests	`test: add unit tests for date filtering`

These labels make it easy to skim your commit history and know what’s what. No need for anything fancy—just pick one and go.

Keep Your Summary Short and Sweet

Next up is the summary. Keep it quick—aim for under 50 characters if you can, but definitely cap it at 72. Write it like you’re giving a command: “Add this” or “Fix that.” It’s a quirky little standard in coding, but it works. For example:

feat: add API endpoint for fetching GitHub activity
fix: resolve bug in date filtering logic
docs: update README with setup instructions

Avoid stuff like “Added a thing” or “Fixing bugs”—it’s too vague or wishy-washy. Be specific, and you’ll thank yourself later.

Add Some Details When It Matters

For bigger changes, a short summary might not cut it. That’s where a detailed description comes in. After your type and summary, leave a blank line, then add a few lines about what you did and why. Here’s one I’d write:

feat: add GitHub activity API

- Fetches user events from GitHub API
- Supports filtering by single date or date range
- Caches results for faster responses

Closes #12

I remember when I first started coding, I’d skip this part entirely. My commit messages were just “updated code” or something equally useless. Weeks later, I’d be lost. Now, I love adding these little notes—especially for tricky fixes or big features. It’s like leaving a cheat sheet for my future self.

Tie It to Issues or Shout Out Your Team

If your commit ties back to an issue or pull request, mention it. Something like Closes #22 or Related to #15 keeps everything connected. And if you’re working with others, give them a nod with:

feat: add webhook support for GitHub activity

Co-authored-by: Edgar Gulay <edgargulay@outlook.com>
Co-authored-by: John Doe <johndoe@example.com>

It’s a nice way to share the credit.

Keep Your History Tidy

We’ve all been guilty of sloppy commits at some point. You know the ones: wip: working on it or fix: bug fixes. What were you working on? Which bug? Let’s avoid that, shall we? Instead, try:

fix: correct timestamp format in API response

It’s specific, it’s clear, and it won’t leave anyone guessing. Your commit history should tell a story, not a mystery.

A Little Bonus Trick

If you’re into automating things, you can set up a Git hook to nudge you into writing good commit messages. Here’s a quick way to do it:

echo 'exec < /dev/tty && git cz --hook || true' > .git/hooks/commit-msg
chmod +x .git/hooks/commit-msg

It’s like having a friendly reminder pop up every time you commit. Not required, but it’s a neat little helper.

Wrapping It Up

So, there you go! Commit messages don’t have to be a drag. Use a type, keep your summary short and punchy, add details when you need to, and avoid the vague stuff. They’re like little notes to your future self and your team—make them count. Happy coding!

Moving flask app to production.

Eddie Gulay — Thu, 16 Jan 2025 22:51:50 +0000

Deploying Flask App in Digital Ocean Droplet

Eddie Gulay ・ Jan 16

#production #flask #generative #gemini

Deploying Flask App in Digital Ocean Droplet

Eddie Gulay — Thu, 16 Jan 2025 22:50:29 +0000

Recently, I read a blog post about customizing APIs from Gemini Models, but when I tried following the instructions, everything got stuck at localhost:5000. Basically, my apps were only visible on my computer. So, I went on a quest to figure out how to make it accessible to everyone. That's when I learned about deploying Flask apps on a Digital Ocean droplet. This guide is like a map to help you do the same, so your projects don't get stuck at localhost:5000 either. Let's share your awesome creations with the world! ✨ It's time to unleash them onto the global stage by mastering the art of deploying Flask applications on a Digital Ocean droplet or any Ubuntu Server.

Step by step guide to deploying Flask app in digital ocean droplet using gunicorn and nginx.

Things we are going to cover

Creating digital ocean droplet
Preparing environment
Actual deployment guide

Creating digital ocean droplet

Go to digital ocean and create an account if you don't have one. here is the link
✨ Digital Ocean 🎉 ~ This is a referral link, you will get $200 credit for 60 days. so no more excuses to why your projects are not deployed.

After creating an account, click on the create button and select droplets. You will be presented with a list of options. Select the Ubuntu 20.04 LTS. Choose the plan of your preference. You can choose any data center region you want. I usually choose the one closest to me.

Choose the authentication method. SSH keys are the best but for this guide, we are going to use a password. You can always add SSH keys later.

if you are a windows user get yourself a virtual box and install Ubuntu. or use WSL 😂.

Preparing environment

Now that we have our droplet up and running, let's prepare our environment.
connect to your droplet using ssh.

ssh root@your_droplet_ip

Provide your password and you are in.

Update and upgrade

sudo apt update
sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools

the command sudo apt update refreshes the list of available software packages on your system, ensuring that it has the latest information from the repositories. Following that, sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools installs essential tools and dependencies for Python development. This includes the Python 3 package manager (python3-pip), development headers for Python (python3-dev), fundamental build tools (build-essential), as well as libraries for SSL and FFI (libssl-dev and libffi-dev), and the Python package distribution tools (python3-setuptools).

Create a virtual environment

sudo apt install python3-venv

Create a directory for your project and navigate to it.

mkdir apps
cd apps

Create a virtual environment

python3 -m venv venv

Activate the virtual environment

source venv/bin/activate

Clone your project

let's call our project flask_app

git clone your_project_url.git
cd flask_app

Install project dependencies

pip install -r flask_app/requirements.txt

now that we have your project up and running, let's run it and see if everything is working as expected.
first lets allow the port we are going to use.

sudo ufw allow 5000

run the app

python app.py

if everything is working as expected, you should be able to access your app using your droplet ip and port 5000.
something like this http://your_droplet_ip:5000

Actual deployment guide

Create WSGI entry point

Create a file called wsgi.py in your project root directory.
or just copy app.py to wsgi.py

cp app.py wsgi.py

Configure Gunicorn

Safe check if gunicorn is installed

gunicorn --version

if not installed install it using pip

pip install gunicorn

try running your app using gunicorn

gunicorn --bind 0.0.0.0:5000 wsgi:app

Check your app using your droplet ip and port 5000. something like this http://your_droplet_ip:5000

if everything is working as expected, let's move to the next step.

Create a systemd service file

Create a systemd service file for gunicorn, this will allow gunicorn to automatically start on boot.
first deactivate your virtual environment

deactivate

Then create a file called flask_app.service in /etc/systemd/system/ directory.

sudo nano /etc/systemd/system/flask_app.service

Add the following configuration to the file

[Unit]
Description=Gunicorn instance to serve flask_app
After=network.target

[Service]
User=root
Group=www-data
WorkingDirectory=/root/apps/flask_app
Environment="PATH=/root/apps/venv/bin"
ExecStart=/root/apps/venv/bin/gunicorn --workers 3 --bind 0.0.0.0:5000 -m 777 wsgi:app

[Install]
WantedBy=multi-user.target

After creating the file, start the gunicorn service and enable it to start on boot.

sudo systemctl start flask_app
sudo systemctl enable flask_app

Check the status of the service to make sure it's running without any issues.

sudo systemctl status flask_app

example output

Configure Nginx to Proxy Requests

Install Nginx

sudo apt install nginx

Create a new server block configuration file in Nginx's sites-available directory.

sudo nano /etc/nginx/sites-available/flask_app

Add the following configuration to the file. Replace your_domain_or_ip with your actual domain name or IP address.

server {
    listen 80;
    server_name 143.198.232.28;

    location / {
        proxy_pass https://143.198.232.28:5000;
    }
}

Create a symbolic link to the file in the sites-enabled directory.

sudo ln -s /etc/nginx/sites-available/flask-app /etc/nginx/sites-enabled

Test your Nginx configuration for syntax errors.

sudo nginx -t

you should see something like this

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

If the test is successful, restart Nginx.

sudo systemctl restart nginx

Remember we allowed port 5000 earlier, now we can remove it.

sudo ufw delete allow 5000

Now you should be able to access your app using your domain name or IP address without the port number. something like this http://your_droplet_ip

Secure your app with SSL

Install certbot

sudo apt install certbot python3-certbot-nginx

Obtain a free SSL certificate for your domain using certbot if you have a domain.

sudo certbot --nginx -d your_domain_or_ip

Certbot will ask you to provide an email address for lost key recovery and notices, and to agree to the terms of service. After doing so, certbot will communicate with the Let's Encrypt server, then run a challenge to verify that you control the domain you're requesting a certificate for.

When that's finished, certbot will ask how you'd like to configure your HTTPS settings.

or you can use openssl to generate a self-signed certificate.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/flask_app.key -out /etc/ssl/certs/flask_app.crt

Create a new server block configuration file in Nginx's sites-available directory.

sudo nano /etc/nginx/sites-available/flask_app

Add the following configuration to the file. Replace your_domain_or_ip with your actual domain name or IP address.


server {
    listen 80;
    server_name

    location / {
        proxy_pass https://your_domain_or_ip;
    }
}

server {
    listen 443 ssl;
    server_name your_domain_or_ip;

    ssl_certificate /etc/ssl/certs/nginx-selfsigned.crt;
    ssl_certificate_key /etc/ssl/private/nginx-selfsigned.key;

    location / {
        proxy_pass https://your_domain_or_ip;
    }
}

This configuration tells Nginx to listen on both port 80 (HTTP) and port 443 (HTTPS). It uses the self-signed certificate and private key that you created.

After updating the Nginx configuration, remember to test the configuration and reload or restart Nginx:

sudo nginx -t
sudo systemctl reload nginx

The nginx -t command checks the configuration for syntax errors. The systemctl reload nginx command reloads the Nginx configuration without interrupting currently connected clients.

Please note that because the certificate is self-signed, browsers will show a warning to users that the site is not secure. Users will need to manually accept the risk and proceed to the site.

Conclusion

Hopefully with this guide, you were able to deploy your flask app in a digital ocean droplet. Your projects are way too precious to be running on localhost. Deploy them and share them with the world. If you have any questions or suggestions, feel free to reach out help is everywhere. ✨

Enhancing your web app's search with OctoPalm.js—a lightweight JavaScript library offering real-time, customizable search functionality. Features include animated results, emoji support, and cross-browser compatibility.

Eddie Gulay — Thu, 09 Jan 2025 14:42:52 +0000

OctoPalm.js || JavaScript library to add real-time, customizable search to your web applications.

Eddie Gulay ・ Sep 19 '24

#javascript #vscode #realtime #search

Building OpenCV 4.10.0 with GUI Support in WSL

Eddie Gulay — Sun, 29 Dec 2024 21:04:34 +0000

If you’re working with OpenCV on WSL and hit the infamous cv2.error stating GUI: NONE, you’ve probably realized that your OpenCV installation lacks GUI backend support. This guide will walk you through building OpenCV 4.10.0 from source with full GUI support, ensuring functions like cv2.imshow work seamlessly. Let’s dive in!

Prerequisites

Before we begin, make sure you have WSL set up (preferably WSL2) with a Linux distribution like Ubuntu. We’ll also need to install several dependencies.

Step 1: Install Required Dependencies

Open your terminal and run the following commands to install the necessary development tools and libraries:

sudo apt update
sudo apt install -y build-essential cmake git pkg-config
sudo apt install -y libjpeg-dev libpng-dev libtiff-dev
sudo apt install -y libavcodec-dev libavformat-dev libswscale-dev
sudo apt install -y libv4l-dev v4l-utils
sudo apt install -y libxvidcore-dev libx264-dev
sudo apt install -y libgtk2.0-dev libgtk-3-dev libcanberra-gtk-module libcanberra-gtk3-module
sudo apt install -y python3-dev python3-pip python3-numpy
sudo apt install -y libopenblas-dev libatlas-base-dev liblapack-dev gfortran
sudo apt install -y libhdf5-dev libprotobuf-dev protobuf-compiler

These libraries ensure that OpenCV can handle image processing, video decoding, and GUI rendering.

Step 2: Download OpenCV and Contrib Modules

To build OpenCV from source, we need both the main OpenCV repository and the additional contrib modules for extended functionality.

Clone OpenCV:

git clone https://github.com/opencv/opencv.git
cd opencv
git checkout 4.x

Clone the Contrib Modules:

cd ..
git clone https://github.com/opencv/opencv_contrib.git
cd opencv_contrib
git checkout 4.x

Step 3: Build OpenCV

Create a Build Directory

Navigate back to the OpenCV directory and create a build directory:

cd ../opencv
mkdir build
cd build

Configure the Build

Run cmake to configure the OpenCV build, ensuring GUI support is enabled:

cmake -D CMAKE_BUILD_TYPE=Release \
      -D CMAKE_INSTALL_PREFIX=/usr/local \
      -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
      -D WITH_GTK=ON \
      -D WITH_OPENGL=ON \
      -D BUILD_EXAMPLES=ON ..

Compile OpenCV

Use the following command to compile OpenCV. This process can take some time depending on your system:

make -j$(nproc)

Here, $(nproc) ensures all available CPU cores are used for compilation.

Install OpenCV

Once the compilation is complete, install OpenCV on your system:

sudo make install
sudo ldconfig

Step 4: Verify the Installation

Let’s check if OpenCV is installed correctly and GUI support is enabled:

Run a Python Script

Open Python and run the following:

import cv2
print(cv2.getBuildInformation())

Look for the GUI section in the output. It should list GTK or similar. If it says NONE, ensure the required libraries were installed before running cmake and repeat the build process.

Step 5: Test `cv2.imshow`

To confirm everything works as expected, try displaying an image:

Sample Python Script:

import cv2

# Load an image
image = cv2.imread('path_to_your_image.jpg')

# Display the image
cv2.imshow('Test Image', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

If a window pops up showing your image, congratulations! You’ve successfully built OpenCV with GUI support.

Troubleshooting Tips

GUI: NONE Still Appears:
- Ensure you installed libgtk2.0-dev and libgtk-3-dev before running cmake.
- Delete the build directory and re-run the cmake and make steps.
Errors During Compilation:
- Check for missing dependencies in the error messages and install them.
- Ensure your system has enough memory; close other programs if necessary.
Display Issues in WSL:
- Use an X server like VcXsrv on Windows if you’re not using WSLg.
- Export your display:
```
 export DISPLAY=$(hostname).local:0
```

Highlight

Building OpenCV 4.10.0 from source may seem daunting, but it’s worth the effort for the flexibility and customization it offers. Whether you’re working on image processing, computer vision, or machine learning projects, having a fully functional OpenCV installation will unlock countless possibilities.

Got stuck? Drop your errors or questions in the comments—I’m here to help!
Happy coding!

Secure Text Encryption and Decryption with Vanilla JavaScript

Eddie Gulay — Tue, 03 Dec 2024 18:02:11 +0000

In today’s digital age, securing sensitive information like API keys, passwords, and user data is more critical than ever. A robust encryption and decryption strategy can prevent unauthorized access and ensure data confidentiality. In this blog post, we’ll explore how to encrypt and decrypt text using vanilla JavaScript, leveraging the Web Crypto API for a modern, secure approach.

Why Use Encryption?

Encryption transforms readable data (plaintext) into a scrambled format (ciphertext) that can only be read if decrypted with the correct key. This ensures that even if someone intercepts the encrypted data, it remains meaningless without the key. A solid encryption mechanism protects:

API keys stored in your frontend code.
Sensitive user information.
Any data transferred over insecure channels.

Let’s dive into how you can implement this securely in JavaScript.

Encryption and Decryption Using AES-GCM

We’ll use AES-GCM (Advanced Encryption Standard - Galois/Counter Mode), a modern standard that provides both encryption and integrity verification. The steps involve:

Password Derivation: Use PBKDF2 (Password-Based Key Derivation Function 2) to derive a secure key from a password.
Salt and IV: Generate a random salt (to make the password derivation unique) and iv (Initialization Vector) for each encryption.
Encryption: Encrypt the plaintext using AES-GCM.
Decryption: Decrypt the ciphertext using the same password and salt/iv.

Code Implementation

Here is the complete JavaScript implementation.

Utilities for Conversion

We’ll convert between ArrayBuffer and hexadecimal for easy data storage and retrieval:

function arrayBufferToHex(buffer) {
    return [...new Uint8Array(buffer)]
        .map(byte => byte.toString(16).padStart(2, '0'))
        .join('');
}

function hexToArrayBuffer(hex) {
    const bytes = new Uint8Array(hex.length / 2);
    for (let i = 0; i < hex.length; i += 2) {
        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
    }
    return bytes.buffer;
}

Key Derivation from Password

Use PBKDF2 to derive a strong encryption key:

async function getCryptoKey(password) {
    const encoder = new TextEncoder();
    const keyMaterial = encoder.encode(password);
    return crypto.subtle.importKey(
        'raw',
        keyMaterial,
        { name: 'PBKDF2' },
        false,
        ['deriveKey']
    );
}

async function deriveKey(password, salt) {
    const keyMaterial = await getCryptoKey(password);
    return crypto.subtle.deriveKey(
        {
            name: 'PBKDF2',
            salt: salt,
            iterations: 100000,
            hash: 'SHA-256'
        },
        keyMaterial,
        { name: 'AES-GCM', length: 256 },
        false,
        ['encrypt', 'decrypt']
    );
}

Encryption Function

Encrypt text with a password:

async function encryptText(text, password) {
    const encoder = new TextEncoder();
    const salt = crypto.getRandomValues(new Uint8Array(16));
    const iv = crypto.getRandomValues(new Uint8Array(12));
    const key = await deriveKey(password, salt);

    const encrypted = await crypto.subtle.encrypt(
        { name: 'AES-GCM', iv: iv },
        key,
        encoder.encode(text)
    );

    return {
        cipherText: arrayBufferToHex(encrypted),
        iv: arrayBufferToHex(iv),
        salt: arrayBufferToHex(salt)
    };
}

Decryption Function

Decrypt text with the same password:

async function decryptText(encryptedData, password) {
    const { cipherText, iv, salt } = encryptedData;
    const key = await deriveKey(password, hexToArrayBuffer(salt));

    const decrypted = await crypto.subtle.decrypt(
        { name: 'AES-GCM', iv: hexToArrayBuffer(iv) },
        key,
        hexToArrayBuffer(cipherText)
    );

    const decoder = new TextDecoder();
    return decoder.decode(decrypted);
}

Example Usage

Let’s see how to use these functions:

(async () => {
    const text = 'MySecretAPIKey123456';
    const password = 'StrongPassword123!';

    // Encrypt
    const encryptedData = await encryptText(text, password);
    console.log('Encrypted Data:', encryptedData);

    // Decrypt
    const decryptedText = await decryptText(encryptedData, password);
    console.log('Decrypted Text:', decryptedText);
})();

Security Best Practices

Use a Strong Password: The encryption is only as secure as the password you use.
Store Salt and IV Safely: Always save the salt and iv alongside your encrypted data.
Avoid Hardcoding Secrets: Never hardcode sensitive data or passwords in your codebase.
Use HTTPS: Ensure your application uses HTTPS to protect data in transit.

Encrypting sensitive information like API keys is a fundamental step in securing your applications. I use this for API keys mostly.

Forem: Eddie Gulay

Under-presentation of Swahili in AI tasks

PostgreSQL Backup the quick Way

Why “Logical” Backups Are Enough

Step 1 — Create the Backup

Step 2 — Verify the Backup

Step 3 — Copy the Backup to Your Local Machine

Optional — Compress the Backup

Step 4 — Restore the Backup (When Needed)

Automation Tip

Setting up SSH for GitHub on Linux Mint

1. Check for Existing SSH Keys

2. Generate a New SSH Key

3. Start the SSH Agent and Add the Key

4. Add the Public Key to GitHub

5. Test the Connection

6. Clone Repositories with SSH

7. Optional: Configure SSH for Multiple Keys

How to Transform Jupyter Notebook into a Maintainable AI Project

Problem, Transitioning from Notebooks to Production Ready Code

Solution, Structured Project Template

Introducing modinit: Automating the Setup

Next Steps

Fed Up with Docker? Here, Uninstall It Completely (No Coming Back!)

Why Uninstall Docker?

Step 1: Stop and Remove Running Containers

Step 2: Uninstall Docker (Ubuntu/Linux)

Purge Docker Packages

Step 3: Clean Up Residual Files

Step 4: Remove Docker Repositories and Keys

Step 5: Autoremove and Clean Packages

Step 6: Verify Docker is Gone

Bonus: Remove Docker Groups and Users (Optional)

Step 7: Reboot (Optional but Recommended)

While sipping monster energy ...

TL;DR:

Writing clear, concise, and meaningful commit messages is key to maintaining a well-documented Git history. Here’s a practical guide to writing great Git commit messages.

Writing clear, concise, and meaningful commit messages for a well-documented Git history

Eddie Gulay ・ Jan 29

Writing clear, concise, and meaningful commit messages for a well-documented Git history

Let’s Talk About Writing Commit Messages That Actually Make Sense

Kick Things Off with a Commit Type

Keep Your Summary Short and Sweet

Add Some Details When It Matters

Tie It to Issues or Shout Out Your Team

Keep Your History Tidy

A Little Bonus Trick

Wrapping It Up

Moving flask app to production.

Deploying Flask App in Digital Ocean Droplet

Eddie Gulay ・ Jan 16

Deploying Flask App in Digital Ocean Droplet

Creating digital ocean droplet

Preparing environment

Update and upgrade

Create a virtual environment

Clone your project

Install project dependencies

Actual deployment guide

Create WSGI entry point

Configure Gunicorn

Create a systemd service file

Configure Nginx to Proxy Requests

Secure your app with SSL

Conclusion

Enhancing your web app's search with OctoPalm.js—a lightweight JavaScript library offering real-time, customizable search functionality. Features include animated results, emoji support, and cross-browser compatibility.

OctoPalm.js || JavaScript library to add real-time, customizable search to your web applications.

Eddie Gulay ・ Sep 19 '24

Building OpenCV 4.10.0 with GUI Support in WSL

Prerequisites

Step 1: Install Required Dependencies

Step 2: Download OpenCV and Contrib Modules

Clone OpenCV:

Clone the Contrib Modules:

Step 3: Build OpenCV

Create a Build Directory

Configure the Build

Compile OpenCV

Install OpenCV

Step 4: Verify the Installation

Introducing `modinit`: Automating the Setup

Step 5: Test `cv2.imshow`