DEV Community: Babacar Cisse DIA

From Childhood Curiosity to Tech Leadership: Babacar's Journey and Insights for Aspiring Developers

Babacar Cisse DIA — Mon, 30 Sep 2024 17:42:00 +0000

Originally published on bcd.dev

Outline

Babacar's Story
Choosing a Career
Internships
Early Projects
Language
Couchbase
Laravel Couchbase
PHP
Python
[Pushing boundaries](#pushing-boundaries]
Artificial Intelligence
Large Language Models
Limiting the scope
Open Source vs Closed Source
Couchbase SQL Plus
Problem Focus
Problem Solving and communication
Pseudocode
Empathy
Ask Questions
Learning Process
Advice for Aspiring Developers
Learning Languages
Future Projects

Photo by Oshomah Abubakar on Unsplash

Interview Transcript

Babacar's Story

Nyah: Let's jump right in if that's okay with you. Sound good?

Babacar: Sure, let's do it.

Nyah: Cool, love it! So my first question is, I always think it's really important for our community to learn more about your story. How did you get started in tech, and what was your journey like?

Babacar: For me, since I was a little kid, I always knew I wanted to work in tech. I was that kid always trying to open things up to see how they worked inside. You’d often find me with a screwdriver, laying all the pieces out and trying to figure out the "why" and "how" behind it all. Fast forward, I knew tech was my path, so I studied it in college. At first, it was hard to decide which area of tech to focus on, so I did something a bit unconventional: I figured out what I didn't want. I started crossing things off the list, and eventually, I realized software engineering was where I wanted to be.

Choosing a Career

Nyah: How did you know what you wanted to focus on in tech? With it being such a vast space, how did you decide what wasn't for you?

Babacar: Back in high school, there was this great website that had profiles for different professions. I’d look at what a typical day was like for each job and think, "No, I don’t like this environment or this kind of work." I kept crossing things off the list, and by the time I got to three options, I knew I wanted to pursue computer science.

Internships

Nyah: Amazing! So did you major in computer science in college?

Babacar: Yes, I did computer science, then information systems, and finally software engineering.

Nyah: Did you do any internships while you were still in school?

Babacar: Yeah, I started working on projects during my second year of college. I also did something that might seem crazy: I’d open job boards and apply for positions where I met only one out of 20 qualifications. I figured, "Okay, let’s keep going," and learned as I went. Eventually, I’d meet more and more qualifications until someone hired me. You don’t need to have 10 out of 10 qualifications to get a job.

Early Projects

Nyah: I know you’ve worked on some open-source projects. What’s one of the first projects you built that you loved, either because it was challenging or creative?

Babacar: I try to build projects that solve my own problems first. One project I remember was a multiplayer game where we had trouble scaling the servers properly. The rooms couldn’t be too big or too small, and it was all new to me at the time. We eventually got it working, which felt amazing because we were under a lot of pressure from the customer.

Language

Nyah: What language did you use for that game?

Babacar: The main application was in Laravel, with some parts in Node.js. It was a mix, but Laravel handled most of it.

Couchbase

Nyah: How did you come across Couchbase, and what made you want to work with it?

Babacar: My first introduction was actually to CouchDB back in college. A professor had us research different databases, not just MySQL or PostgreSQL. Later, at work, the enterprise architect decided we needed a NoSQL solution, and Couchbase was proposed. We were already using Laravel, and Couchbase had an Eloquent driver that made it easy to integrate into the Laravel ecosystem.

Laravel Couchbase

Nyah: What problem were you solving with Laravel Couchbase?

Babacar: Laravel comes built-in with SQL database support, but Couchbase didn’t have official support. We found a five-year-old driver that hadn’t been updated, so we upgraded it to support the latest Laravel syntax and Couchbase versions. The goal was to keep it up-to-date and maintain it, even if we’re no longer using Couchbase ourselves.

PHP

Nyah: So is PHP your go-to programming language?

Babacar: I see languages as tools. It depends on the project. But for the last few years, yes, I’ve mainly worked with PHP and Laravel. That said, I also work with JavaScript and Python, though my Python is a bit rusty now.

Python

Babacar: I haven't worked with it for about two years, but when I was using it, Python was one of my favorite languages. Now, of course, I'm working with JavaScript. JavaScript allows you to make a lot of different mistakes—you can do almost anything with it. That’s one of the reasons I love TypeScript. The strict typing provides guardrails; it doesn’t let you create a variable that could be a string, a number, or anything else.

Nyah: I'm with you 100%, that's funny.

Pushing boundaries

Nyah As a developer, how do you push the boundaries and explore new technologies? Couchbase, for example, was something you didn’t know before, but then you realized it was an incredible technology to build off of. How do you stay up to date with the latest trends?

Babacar: To be honest, it’s not easy. There’s always something new coming around the corner. If you just follow the conversations, it might seem like everyone is using the latest trend, but in reality, most people are still running Java and PHP on their web servers. That said, I’m curious by nature, so I try to stay up to date—not 100%, but I keep an eye on things from a distance. I follow different runtimes, languages, and frameworks to see what people are building with them. Sometimes I find something interesting to work on or even join the trend.

After work, I usually spend about an hour or less digging through social media or YouTube, letting the algorithms recommend content to me. I pick a couple of topics, create a study plan, and decide which ones I want to become proficient in. I also make sure to keep revisiting certain things to reflect on what I’ve learned, both for work and personal growth. Revisiting things helps me reassess my understanding over time.

Artificial Intelligence

Nyah: Are you diving into AI at all?

Babacar: Yes, definitely. I’ve been exploring crypto and AI. I’m interested in the potential of AI but also cautious. Right now, I’m more focused on data science because you can do a lot with just that. Machine learning and AI are huge, but sometimes simpler solutions are all you need.

Large Language Models

Nyah: Have you worked with large language models (LLMs)?

Babacar: I haven’t done a lot with LLMs yet. My idea is more about using smaller, focused models that do one thing really well rather than trying to have one giant model do everything.

Limiting the scope

Nyah: I love that you’re thinking about limiting the scope a bit. You mentioned using a much smaller model that's very focused and does one thing really well, rather than relying on large language models (LLMs) that try to do everything. We often see LLMs generate hallucinations—things that just aren’t true. For example, they might provide a code sample that looks plausible, but as software engineers, we quickly realize it's wrong.

Babacar: Exactly. There are definitely challenges with LLMs. What I’d like to see, as you mentioned, is AI used in a more tailored, specific way to repeatedly achieve a well-defined task. I think that’s a space we’re currently missing—a model that excels at one thing, rather than trying to create something that mimics the human mind and handles everything. Scoping AI down can lead to better results.
It feels like every AI tutorial or blog post these days ends with a sales pitch. They’ll walk you through a basic setup, only to steer you towards signing up for a platform. Once you sign in, you're essentially locked in and can’t use anything else. That’s not AI—that’s just platform dependency.

Nyah: Exactly, and that’s a big difference. It's not true AI if you're just using someone’s platform. You're tied to that ecosystem.

Open Source vs Closed Source

Nyah: How do companies and developers navigate the balance between open-source and closed-source platforms? For example, with OpenAI, when you're using ChatGPT, you're on their platform, and many are paying for that. But there are also open-source versions of AI, specifically LLMs. How can we build models based on open-source data and make them fully open, rather than locked into a closed-source system?

Babacar: That’s a good point, and it’s part of the process. I'm currently working on a series of "do it yourself" projects that focus on going back to basics. If you understand the fundamentals, you can navigate both old and new technologies, even those you’ve never encountered. For example, if you have a solid understanding of how databases work—whether relational or not—you can adapt quickly. That’s what I love about CQL. Coming from a relational database background, I didn’t feel lost when using it because it’s quite similar, just with its own syntax. This familiarity helped me speed up my workflow on that project.

Couchbase SQL Plus

Nyah: That's perfect! You already know Couchbase has SQL Plus+, which is our version of SQL. It translates easily for people who already know SQL, and even for those unfamiliar with SQL, we have Capella IQ, an AI that teaches the syntax for creating queries within Couchbase SQL Plus. It equips users with all the skills they need to learn a new querying language, which is incredible. So, artificial intelligence can be used to educate and create platforms for learning, which is a huge long-term benefit.

Many developers are still apprehensive about AI, which is understandable since it's new, but the conversation around it has been going on for years. Once people learn the tailored benefits and tools AI can offer, it's a massive win. I love that!

Babacar: Absolutely. AI can do so much for education, especially in something like SQL Plus+, where people can quickly learn the language. It’s great to see platforms that not only provide the tech but help people learn to use it effectively.

Problem Focus

Nyah: It’s great work. So thinking about our larger state as engineers and how technology is shaping the future, what roles do developers and engineers have in that transformation?

Babacar: Right now, there’s almost nothing you can do without tech. I was just talking to someone in construction, and they have a massive IT department working internally. It doesn’t matter what field you're in—eventually, you'll need tech. Without it, you won’t stay relevant. The role of engineers is to ensure systems are working, tested thoroughly, and easy for people to navigate. Whether it's an API or a website, it’s ultimately for someone else to use, so empathy plays a big part. Technology evolves, but the theories behind it don’t.

Nyah: Exactly. It's vital to ensure that technology is accessible, not just to tech elites but also to the general population. It’s about making it usable for everyone—from seniors who may be intimidated by technology to children growing up with it. It needs to be safe and accessible.

Babacar: Absolutely. Developers should focus on applying technology to solve real-world problems. AI and data science are examples where you don't always need deep learning—sometimes, data science alone can get you there. It depends on the use case. I also like talking to people from different fields to see the problems they're facing and come up with solutions. It’s about applied technology, which is always more interesting than working with tech in a vacuum.

Nyah: Agreed. It's about problem-focused solutions, understanding preferences, and sometimes even controlling a market. Take Apple, for example, with their seamless ecosystem—it drives preferences.

Babacar: Exactly. Cross-pollination is key.

Problem Solving and communication

Nyah: How do you approach problem-solving in your development work?

Babacar: I like to break things down into smaller steps. I start with an MVP (minimum viable product), and then iterate on it. It doesn’t have to be perfect at first, but through iteration, you get closer to the best solution.

Nyah: The importance of pseudocode cannot be overstated. I always recommend writing out your pseudocode first in plain language—whatever you speak to yourself in daily. Just write out the problem statement or what you want the code to achieve. Once you've laid out the entire problem, only then should you start creating functions or writing the actual code in JavaScript, TypeScript, Python, or whatever language you’re using. It helps to clarify the steps before diving into the actual code.

Babacar: That's a great approach. When I’m working on something complex, I break it down into small, manageable steps and write everything out in plain text. No code, no algorithm at first—just an explanation that's easy to understand. Once the steps are clear, the algorithm and code follow naturally.

Nyah: Exactly! I think many developers forget the power of pseudocode. Writing out the logic before coding can save time and avoid confusion. Speaking of communication, engineers are often seen as bad communicators. How do you effectively communicate and collaborate with your teammates or clients?

Babacar: I start with empathy. You need to be able to read people, especially since you may not share the same values or culture. Being able to understand where someone is coming from makes collaboration easier. We get a bad reputation for being poor communicators, but solving complex problems requires clear communication. Translating difficult concepts into something everyone can understand is crucial. Writing the code is the easy part; explaining the problem and the solution is the challenge.

Nyah: Absolutely. Communication is key, and it’s something we all need to work on continuously.

Pseudocode

Nyah: Absolutely. Communication is key, and it’s something we all need to work on continuously.

Empathy

Nyah: You started by emphasizing empathy, and I think that’s absolutely key. Taking your ego out of conversations is essential. It’s not about pushing your own perspective or saying, "This is my code, so we must develop it this way." It’s about listening to the wants and needs of the team, the company, and the community.

Babacar: Exactly. We often get into debates—like "I like React, you like Vue," and the conversation turns into a competition. But if something solves the problem, why argue? Empathy means being open to change and new ideas. Otherwise, you might find yourself sticking to one technology for the rest of your life without exploring new frameworks. It's about being flexible and open-minded.

Nyah: Yes, and that openness allows teams to work together towards a common mission. It’s not about personal preferences, but about achieving shared goals.

Babacar: Absolutely. I might be naturally empathetic, but I always try to stay open—open your eyes, open your ears, ask questions, and never assume anything. That’s the key to effective collaboration and growth.

Ask Questions

Nyah: Yes, 100%. Asking questions is crucial, and yet so many of us are afraid to ask because we don’t want to feel dumb or uninformed, especially as we grow into more senior roles. People expect us to have all the answers, but being honest about what we don’t know is actually a powerful thing. Most senior engineers I talk to often say, "It depends." That’s a perfect answer because it’s true—you have to consider different factors for every problem.

Babacar: Exactly. Asking questions is a lifelong skill, especially in tech. You’ll always have to ask questions and keep learning, because no one knows everything. Even those with 25+ years of experience are still searching for answers. Tech is always evolving, and understanding that the learning process never ends is important.

Nyah: Absolutely. Look at how coding used to be done on punch cards back in the day. The process and tools are vastly different now. The key is to stay curious, keep asking questions, and know that this process is ongoing.

Babacar: Ego has no place in this conversation, especially when working with a team. If I can’t convince someone that my way is the best way, maybe I’m wrong. It’s important to hear others out and reconsider your approach.

Nyah: Exactly. That openness to feedback is what drives growth and collaboration.

Learning Process

Babacar: Like you mentioned, taking ego out of the equation and being willing to admit, "Maybe I’m wrong," is key. I’m always willing to step back and learn from others. Let's try it their way, and whether it works or not, it's okay. We're going through this process together as a team. At the end of the day, we’re a unified team—if we win, we win together; if we lose, we lose together.

Nyah: Absolutely. Back when I was an engineer, we had the mentality of "we break production together." If code went to production and something went wrong, it wasn’t one person's fault—it was a team issue. We’d learn from it and grow together, and that’s the kind of collaborative environment that’s so crucial. I love that you’re cultivating that kind of space at Kirschbaum.

Babacar: Exactly. It's all about learning and improving together. There’s always room to grow, and that process never stops.

Nyah: Yes, and I’m glad you mentioned that willingness to keep learning. It’s not about knowing everything; it’s about continuously improving, and communication is a huge part of that. When engineers can communicate and collaborate effectively, the whole team grows.

Advice for Aspiring Developers

Babacar: It's important to iterate on code, improve it, and not just stop after shipping the MVP. The willingness to come back, reassess, and have an honest conversation about the current state is crucial. That’s what we call managing tech debt—it’s about constantly improving, not just settling for "it works."

Nyah: Exactly! That’s a great point. For junior developers, or those aspiring to get into the field, what advice would you give them?

Babacar: I often tell aspiring developers to take it easy and go step by step. We didn’t learn everything overnight. No one starts with 10 years of experience. For example, we didn’t learn Laravel before learning PHP. First, we learned HTML and CSS, then PHP, and eventually JavaScript. After that, maybe Vue or React. You don’t need to force yourself to learn all these technologies in a few months, as many bootcamps might suggest.

Take it one step at a time. You don’t need to be an expert in everything, but you should know enough to work with a technology. Once you find what you’re passionate about, dive deeper into that area. This approach applies not just to tech, but to learning in any field.

Nyah: That’s so true! Learning progressively, building solid foundations, and going deeper into areas of interest is the best way to grow as a developer.

Learning Languages

Nyah: Yes, exactly! Take it slow. Don't feel like you have to learn six languages in two months. Be patient with yourself. Learning programming languages is similar to learning human languages—it’s a process. We didn’t become fluent in a language at two months old, right? It starts with simple sounds, and over time we grow, learn structure, and eventually master it. That’s the same approach we need for programming. It takes time, and that’s okay.

Babacar: Absolutely. You need to stumble, make mistakes, and grow. Learning takes time, and being patient with yourself is key. It’s important to understand that it’s a gradual process and to be proud of each step forward.

Nyah: 100%! And what’s your favorite learning resource that you’ve used to master different languages?

Babacar: Honestly, I’m still Googling to this day! I don’t have a specific resource because I like to change things up. I dive deep into subjects I’m interested in, then circle back and check what I may have missed. I like using different resources for different perspectives. For example, I’ll watch a Laravel series from one source, then watch a similar series from another to see how they explain it differently. Even watching beginner-level tutorials can give you that extra 1% of knowledge you missed before.

What matters most is knowing how to use tools like Google effectively and how to ask the right questions. Once you break down problems into smaller, manageable chunks, it becomes much easier to build from there and work your way up to more complex issues.

Future Projects

Nyah: One of the biggest challenges for new engineers is knowing how to ask the right questions. Sometimes, they don't even know how to begin asking. But that's part of the learning process—knowing how to use tools like Google to get answers and figuring out what to input to get the information you're looking for.

Babacar: Exactly. It’s all about understanding how to ask the right questions. As for future projects, IoT (Internet of Things) is a big focus for me right now. For example, I recently spent two weeks installing a GPS on my bike, which was very different from just coding. I also bought an electronics kit to dive deeper into that side of things. IoT has been a side project for many years, and I’d love to dedicate more time to it. I’m even thinking about creating an intelligent field that handles tasks like watering soil based on sensor data, adjusting for sunlight, and changing angles based on the time of day or year.

Nyah: That sounds amazing! Any plans involving AI?

Babacar: Not at the moment. For me, it all depends on the use case. I don’t currently have a problem that AI can solve, but I’m always on the lookout. Aside from IoT, I’m also exploring different protocols—like RTSP, a protocol for resumable file uploads that I just recently discovered. It works over HTTP, and I’m interested in learning more about protocols beyond the usual FTP or SSH.

Nyah: Wow, I love how varied your interests are! Looking forward to seeing what you build.

Where can people find you online if they want to follow your journey?

Babacar: I’m active on Twitter as @babacarcissedia and you can also check out my website at Kirschbaum Development, where I document my projects and share resources.

Originally published on bcd.dev

Setting Up Laravel on Your Own Server: A DIY Guide

Babacar Cisse DIA — Mon, 30 Sep 2024 17:34:46 +0000

Originally published on bcd.dev

Before you go through the pain and challenge of configuring your own server you should perhaps consider Laravel forge. I trust they would know better how to deploy a laravel app.

For curious minded people, this is part of a bigger series Do it yourself series

Components

webserver
- nginx
database
- mysql
php
composer
node
npm / yarn
scheduler
firewall
log
- papertrail
search
- elastic search
- algolia
other third party services
- redis

Basic build

recepee on an ubuntu server (22-10)

mysql
php
composer
node
nginx
queue

Requirements

VPS Server
Valid DNS record pointing to your server

Mysql

sudo apt-get install -y mysql-server

# Init project by creating a user with a dedicated database
name=$1
username=${2:-$name}
password=${3:-$name}
root_username=${4:-'root'}
root_password=${5:-''}
echo '' > tmp.sql
echo "CREATE USER $name@localhost identified by \"$password\";" >> tmp.sql
echo "CREATE DATABASE $name charset utf8 collate utf8_general_ci;" >> tmp.sql
echo "GRANT ALL PRIVILEGES ON $name.* to $name@localhost;" >> tmp.sql
mysql -u$root_username -p$root_password -e "source tmp.sql"


mysql -u$root_username -p$root_password -e "CREATE DATABASE $name charset utf8 collate utf8_general_ci;"

Php

sudo apt install -y software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update

# php with some extensions
PHP_VERSION=${1:-'8.2'}
sudo apt-get install -y "php$PHP_VERSION" php$PHP_VERSION-{common,cli,fpm,zip,xml,pdo,mysql,mbstring,tokenizer,ctype,curl,common,curl,gd,intl,sqlite3,xmlrpc,xsl,soap,opcache,readline,xdebug,bcmath}

Composer

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

# For simplicity purpose, we are skipping the hash check. That is a crucial step you wouldn't want to skip when downloading stuff on the internet
# Hash below matches composer version 2.1.3
# php -r "if (hash_file('sha384', 'composer-setup.php') === '756890a4488ce9024fc62c56153228907f1545c228516cbf63f885e036d37e9a59d27d63f46af1d4d07ee0f76181c7d3') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"
sudo mv composer.phar /usr/local/bin/composer

Node

You can get node on their website but I prefer getting specific version from node version manager (nvm)

version=${1:-'20'}
echo "Installing nvm + node $version"
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
source ~/.bashrc
nvm install $version
# Optional but I like yarn so here we go
nvm exec $version npm i yarn -g

Nginx

# Making sure apache is not installed to avoid conflict on port 80
sudo apt-get remove -y apache
sudo apt-get install -y nginx
rm /etc/nginx/sites-available/default  /etc/nginx/sites-enabled/default 

name=$1 # site.domain
webroot=${3:-"/var/www/vhosts/$name"}
mkdir -p $webroot
touch "/etc/nginx/sites-available/$name.conf"
ln -s "/etc/nginx/sites-available/$name.conf" "/etc/nginx/sites-enabled/$name.conf"
cat >> "/etc/nginx/sites-available/$name.conf" << EOF

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    root $webroot;
    server_name $name www.$name;
}
EOF

Secure traffic using HTTPS

At this point we are running a web server on port 80. However everyone can see the content flowing through the networking. Welcome https.

domain=$1
email=${2:-"your@email.com"}
sudo apt-get install -y python3-certbot-nginx


# manual
# certbot certonly -a manual --rsa-key-size 4096 --email $email -d $domain -d www.$domain

# auto
## With base nginx config
certbot certonly --nginx --rsa-key-size 4096 --email $email -d $domain -d www.$domain

When the steps above succeed you can carry on with nginx config for ssl. The following will redirect all non secure connection (80) to secure connection (443)

# Usage ./laravel.sh site.domain 8.2 ~/sites
## Dependencies: letsencrypt, php$php_version, php$php_version-fpm

# sudo apt-get install -y php$php_version php$php_version-fpm
name=$1 # site.domain
user=$2
php_version=${3:-'8.2'}
root=${4:-"/var/www/vhosts/$name"}
webroot=${5:-"/var/www/vhosts/$name/public"}
touch /etc/nginx/sites-available/$name.conf
ln -s /etc/nginx/sites-available/$name.conf /etc/nginx/sites-enabled/$name.conf

mkdir -p /var/www/vhosts/$name/storage/logs
touch /var/www/vhosts/$name/storage/logs/error.log
touch /var/www/vhosts/$name/storage/logs/access.log

cat >> /etc/nginx/sites-available/$name.conf << EOF

# Force HTTPS
server {
  listen 80;
  listen [::]:80;
  server_name $name www.$name;
  return 301 https://$name\$request_uri;
}

# Force www less version'
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name www.$name;
    ssl_certificate /etc/letsencrypt/live/$name/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/$name/privkey.pem;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
    return 301 https://$name\$request_uri;
}


server {
    server_name $name;

    # SSL config
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_tokens off;
    ssl_buffer_size 8k;
    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
    ssl_ecdh_curve secp384r1;
    ssl_session_tickets off;

    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4;

    ssl_certificate /etc/letsencrypt/live/$name/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/$name/privkey.pem;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
    # End of SSL config


    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";
    add_header X-XSS-Protection "1; mode=block";

    charset utf-8;

    index index.php index.html;
    error_log $root/storage/logs/error.log;
    access_log $root/storage/logs/access.log;
    root $webroot;
    error_page 404 /index.php;


    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";


    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    location / {
        try_files \$uri \$uri/ /index.php?\$query_string;
        gzip_static on;

        proxy_set_header        Host \$server_name;
        proxy_set_header        X-Real-IP \$remote_addr;
        proxy_set_header        X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header        X-Forwarded-Proto \$scheme;
    }

    location ~ \.php$ {
        try_files \$uri /index.php =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php$php_version-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME \$document_root\$fastcgi_script_name;
        fastcgi_param PATH_INFO \$fastcgi_path_info;

        fastcgi_buffers 8 64k;
        fastcgi_buffer_size 128k;
        fastcgi_connect_timeout 3000;
        fastcgi_send_timeout 3000;
        fastcgi_read_timeout 3000;
    }

    location ~ /\.(?!well-known).* {
        deny all;
    }

    # Define caching rules for static images
    location ~* \.(jpg|jpeg|png|gif|ico)$ {
        expires 30d; # adjust the caching duration as needed
        add_header Cache-Control "public, max-age=2592000";
    }

    gzip on;
    gzip_types text/plain text/css application/javascript image/*;

    client_max_body_size 128m;
    # For unlimited
    # client_max_body_size 0;
}
EOF

# permissions
sudo find storage -type f -exec chmod 664 {} \;
sudo find storage -type d -exec chmod 775 {} \;
sudo chmod -R ug+rwx storage bootstrap/cache
sudo chgrp -R www-data storage bootstrap/cache
sudo usermod -aG $user www-data
sudo chown $user:www-data -R storage bootstrap/cache

# Check file exists
# /etc/ssl/dhparams.pem
# Generate if not
# openssl dhparam -out /etc/ssl/dhparams.pem 4096


cat >> /etc/php/$php_version/cli/php.ini << EOF
post_max_size=128M
upload_max_filesize=128M
max_upload_file=50
EOF

Auto renew certificate

# DISCLAIMER: it is safer to edit cron file using crontab dedicated command
# That being see given this is a script we likely want to have automated
/var/spool/cron/crontabs

## cron job to auto renew every 3 months for you
crontab -e
# 0 0 1 */3 * /usr/bin/certbot renew --quiet

## I saw people doing it monthly
# 0 0 1 * *

Queue

#! /bin/bash
user=${0:-$(USER)}
root_dir="/home/$user/www/"
processes=4
sudo apt get install -y supervisor
cat >> /etc/supervisor/conf.d/laravel-worker.conf << EOF
process_name=%(program_name)s_%(process_num)02d
command=php ${root_dir}/artisan queue:work --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=${user}
numprocs=${processes}
redirect_stderr=true
stdout_logfile=${root_dir}/storage/logs/worker.log
stopwaitsecs=3600
EOF

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start all

Conclusion

No conclusion as this is a starting point only but gets you an operational laravel app.
Made a lot of arbitrary choices. Adapt for your usecase.
Next up

automate script using orchestration (ie ansible)
deploy using aws code deploy
CI / CD pipeline from github
tighting security with firewall policies
monitoring
load management / balancing

Originally published on bcd.dev

Would you rather be a "Jack-of-all-trades" or "Master-of-one"? Why?

Babacar Cisse DIA — Mon, 30 Sep 2024 17:29:00 +0000

Originally published on bcd.dev

Short answer: Master of one.

As for many things my more elaborate answer would be it depends.

It is valuable to be a Jack of all trades when working with a team. Your proficiency in many areas lifts up communication barrier, reducing the knowledge lost when translating terms.

If I had to pick one I would go with Master of one. The reasoning behind is simple: Would you go to eye doctor for laser chirurgie or a generalist ?! My guess is you are going with the expert

Living vs. Surviving: How to Stop Going Through the Motions and Start Thriving

Babacar Cisse DIA — Mon, 30 Sep 2024 17:26:17 +0000

Originally published on bcd.dev

Outline

Are You Living or Surviving?
The Rat Race: Fighting an Unwinnable War
Understanding Business, Understanding Life
The Best Time to Be Alive
Abundance in Every Area
What Do You Really Want?
Aligning Actions with Goals
Actions Speak Louder Than Words
The Softness of Modern Society
Hard Times vs. Easy Times
Stop Making Excuses
Take Ownership of Your Life
Human Potential: Tapping into What We’re Capable Of
Are You Fleeing from Reality?
Finding Peace and Gratitude
Conclusion

Photo by Danka & Peter on Unsplash

Are You Living or Surviving?

In today’s fast-paced world, many of us are simply going through the motions. We wake up, work, check off the tasks on our to-do lists, and repeat the cycle the next day. But is this truly living, or are we just surviving? Living means engaging with life fully, embracing purpose and joy, while survival is a bare minimum state where we’re just trying to get by.

The difference between the two may seem subtle, but it has a profound impact on our well-being and fulfillment. Many of us, unknowingly, are stuck in the rat race, striving to reach arbitrary goals without stopping to reflect on whether we’re truly living. The good news is that making the shift from surviving to thriving is entirely possible, and it begins with awareness and intentionality.

The Rat Race: Fighting an Unwinnable War

The rat race is a term used to describe the never-ending cycle of working, competing, and chasing success, often without fulfillment. In this battle, there is no true winner. We’re constantly chasing the next goal—whether it’s more money, status, or approval—but when we reach it, we immediately look for the next target. It’s a constant grind, a cycle of living to see the next day without experiencing the fullness of life.

In this state, we become disconnected from our purpose and what truly matters. Every day feels like a battle without a winner. The irony is, many of us don’t even stop to ask ourselves why we’re in this race to begin with. The lack of reflection and self-awareness keeps us stuck, running on a hamster wheel that never leads anywhere fulfilling.

Understanding Business, Understanding Life

Interestingly, the more we understand business, the more we can understand life itself. Business is often about strategy, growth, and resource management, which can also apply to how we live our lives. In both areas, the key to success is having clear goals, focusing on what matters, and avoiding distractions. Just as businesses set objectives and take action to achieve them, we must do the same in our personal lives.

The trick is recognizing that life, like business, requires a vision and a plan. Without these, we’re just moving from one task to another, checking off boxes without feeling truly accomplished. Success in life, much like in business, comes from a balance of planning, effort, and reflection.

The Best Time to Be Alive

It’s easy to feel overwhelmed by the challenges of modern life. However, the reality is that we are living in one of the best times in history. Abundance is everywhere. We have access to food, shelter, air conditioning, heating, knowledge, safety, and peace—things that were luxuries not so long ago. Yet, with all this abundance, why do so many of us feel like we’re just surviving?

Abundance in Every Area

It’s important to acknowledge that we live in a time of unprecedented abundance. Everything from basic needs like food and shelter to luxuries like knowledge and safety is more accessible than ever before. But this abundance has created a paradox: the easier life becomes, the more we fall into complacency. We become soft, comfortable, and less driven to seek more meaningful goals.

While having access to everything we need is a privilege, it’s also a challenge. When life is too comfortable, we lose the drive to push ourselves. We settle for mediocrity instead of striving for excellence. This is why, despite the abundance around us, many of us feel unfulfilled—we’re not challenging ourselves enough, and we’re not living with purpose.

What Do You Really Want?

It’s time to ask yourself the tough question: What do you truly want? This isn’t a superficial question about material desires; it’s about your deeper life goals. What do you want from life? What do you want for yourself today? What’s stopping you from achieving it right now?

Aligning Actions with Goals

If you find yourself constantly saying you want something but not taking the necessary steps to achieve it, it’s time to reevaluate. Are your daily actions aligned with your goals? If not, you might need to reconsider whether you truly want what you say you do. Real desire is reflected in action. If you’re not taking steps toward your goals, you don’t want them as much as you think.

Actions Speak Louder Than Words

Words are easy, but actions are what truly matter. It’s simple to say that you want to improve your life, get a promotion, or achieve a certain goal. But without action, those words mean nothing. Everything you want is out there for you to take, but it’s not free. It requires your time, your energy, or your money—and sometimes all three.

The truth is that what you do matters far more than what you say. It’s not enough to declare your intentions; you need to work toward them consistently. Whether it’s waking up earlier, investing in yourself, or learning new skills, every action you take gets you one step closer to your goals.

The Softness of Modern Society

Today’s society is often characterized by comfort and convenience, but that comfort can make us soft. People want the rewards without putting in the work. Everyone wants the fruits of labor, but few are willing to till the soil. Abundance has created a generation of people who are quick to complain, slow to act, and often unprepared for the challenges of life.

Hard Times vs. Easy Times

There’s a saying: “Hard times create strong people, and easy times create weak people.” This reflects the idea that when life is too easy, people become complacent and lose the drive to work hard. The more abundant our surroundings, the less motivated we are to push ourselves beyond our comfort zones.

In easy times, we become weaker—not physically, but mentally and emotionally. We lose the resilience that comes from overcoming obstacles, and we settle for a life that is easy but unfulfilling. The solution? Challenge yourself. Push beyond the comfort of everyday life, and seek out opportunities for growth and improvement.

Stop Making Excuses

At the core of transitioning from survival to thriving is personal accountability. Too often, we make excuses for why we’re not where we want to be. We blame external factors—our job, the economy, or our circumstances—but rarely do we look inward and take responsibility for our choices.

Human Potential: Tapping into What We’re Capable Of

As a species, we are brimming with untapped potential. The human capacity for innovation, growth, and improvement is astounding, yet many of us fail to reach our fullest abilities. The reason? Often, it’s not a lack of opportunity but rather a lack of vision or motivation. As long as you’re committed to improving, and as long as you can clearly envision what you want to achieve, the potential is limitless.

But why do so many of us fall short? Some choose to stay in their comfort zones, doing only what’s required, like “working their wage” without striving for more. Others feel they don’t owe it to themselves or the world to push beyond the bare minimum. This mindset is one of self-limitation, and it keeps us from realizing just how much we’re capable of.

The key to unlocking your potential is self-awareness and determination. The world is full of opportunities, but it’s up to you to seize them. It starts with a clear vision and a commitment to taking action.

Are You Fleeing from Reality?

Many people, instead of confronting life’s challenges head-on, find ways to escape or distract themselves. This can come in various forms—avoiding difficult conversations, procrastinating, or even numbing feelings with distractions. But the question is: are you truly at peace with yourself?

Being at peace means facing reality, accepting your flaws, and loving yourself regardless of external circumstances. It means being grateful for the blessings you have, rather than constantly focusing on what’s missing. The truth is, most of us have far more than we realize, yet we tend to fixate on the finite list of problems.

If you can cultivate a mindset of gratitude, self-love, and peace, you’ll start to see life differently. The obstacles may remain, but your perspective will shift. You’ll recognize the blessings that surround you and understand that, while problems are inevitable, they are far fewer than the endless list of things you should be thankful for.

Take Ownership of Your Life

It’s time to stop making excuses and start taking ownership of your life. If you’re not where you want to be, ask yourself why. Are you truly doing everything in your power to achieve your goals, or are you looking for reasons why you can’t succeed?

Stop waiting for a hero to save you, stop sitting around hoping for a miracle, and stop waiting for the perfect moment to act. The perfect moment doesn’t exist. Success doesn’t come from waiting; it comes from doing. The world will keep spinning with or without you, and the sun will continue to rise and set each day. So why wait? If you want to change your life, you need to start taking action today.

Conclusion

From surviving to truly living, the key is intentionality. Life offers more potential, abundance, and opportunities than we often realize, but it’s up to us to harness them. Whether it’s aligning your actions with your goals, taking ownership of your life, or tapping into your true potential, the power to change your circumstances lies within you. Stop fleeing from reality and embrace it. Be grateful for the blessings you have, and make peace with yourself. The best time to start thriving is now.

Originally published on bcd.dev

Optimizing Sorting and Filtering on JSON Columns in Laravel with Indexed Virtual Columns

Babacar Cisse DIA — Wed, 25 Sep 2024 16:51:20 +0000

Originally posted on bcd.dev

Outline

JSON Column Performance Challenges
- Monitoring and Execution Time Issues
- Sorting and Filtering with JSON Columns
Introducing Virtual Columns
- Why Virtual Columns Work Better
- How to Implement Virtual Columns
Benchmarking the Results
- Before: Nested JSON Columns
- After: Virtual Column + Index
How to Optimize JSON Queries with Virtual Columns
Conclusion and Best Practices

JSON Column Performance Challenges

Working with large datasets stored in JSON columns presents significant performance issues, especially when filtering and sorting. In my experience, these challenges became evident while monitoring PHP processes and managing large volumes of records, leading to execution time limits being hit.

Monitoring and Execution Time Issues

As part of my regular monitoring duties, I encountered max execution times of 30 seconds while querying JSON columns in a 580k record dataset. JSON columns, though flexible, are prone to performance bottlenecks, particularly without proper indexing.

Sorting and Filtering with JSON Columns

The first major issue appeared when working on a Filament list record page, which had default sorting applied to a JSON attribute. The absence of indexing on this attribute resulted in a significant slowdown, especially when processing over 10,000 records. Without an index, querying and sorting through nested JSON attributes can cause execution delays and inefficiencies in retrieving results, pushing PHP processes beyond acceptable limits.

Introducing Virtual Columns

When faced with performance issues from sorting and filtering large JSON columns, I revisited an old solution: virtual columns from my friend Rob Fonseca. Virtual columns in MySQL allow me to create an indexed, computed column from JSON data, making queries more efficient without duplicating data.

Why Virtual Columns Work Better

Unlike standard JSON columns, virtual columns are calculated automatically from existing data but can be indexed, making them faster for querying. This improves sorting and filtering performance significantly, especially in large datasets where execution time is critical.

How to Implement Virtual Columns

I implemented virtual columns by adding a migration that created a new indexed column for filtering and sorting. This virtual column extracted and indexed specific JSON attributes, drastically improving query performance. Here's an example migration:

$table->string('approved_at')
    ->nullable()
    ->virtualAs("json_unquote(json_extract(data, '$.latest_approval_date'))");
$table->index('approved_at');

By indexing this virtual column, I was able to reduce query times and improve overall efficiency, especially when filtering and sorting large datasets.

Benchmarking the Results

Once I implemented the virtual columns, I needed to ensure the performance gains were real. Benchmarking provided concrete data, comparing the execution times of filtering, sorting, and paginating large datasets using both the original nested JSON column and the new virtual column with indexing.

Before: Nested JSON Columns

With over 580k records, queries on the nested JSON column were slow:

Sorting a page of 100 records took over 5,000ms.
Filtering + sorting + paginating took nearly 2,000ms.

Benchmark::dd([
    'count' => fn () => Document::count(),
    'paginate' => fn () => Document::paginate(100),
    'filter + paginate' => fn () => Document::where('data->latest_approval_date', '>', '2024-09-05')->paginate(100),
    'sort + paginate' => fn () => Document::orderBy('data->latest_approval_date')->paginate(100),
    'filter + sort + paginate' => fn () => Document::where('data->latest_approval_date', '>', '2024-09-05')->orderBy('data->latest_approval_date')->paginate(100),
], iterations: 100);

After: Virtual Column + Index

After indexing the virtual column, the improvements were substantial:

Sorting the same page of 100 records dropped to 750ms (7.5x faster).
Filtering + sorting + paginating improved to just 53ms (36x faster).

These benchmarks confirmed the effectiveness of virtual columns in optimizing query performance.

Benchmark::dd([
    'count' => fn () => Document::count(),
    'paginate' => fn () => Document::paginate(100),
    'filter + paginate' => fn () => Document::where('approved_at', '>', '2024-09-05')->paginate(100),
    'sort + paginate' => fn () => Document::orderBy('approved_at')->paginate(100),
    'filter + sort + paginate' => fn () => Document::where('approved_at', '>', '2024-09-05')->orderBy('approved_at')->paginate(100),
], iterations: 100);

Steps

1. Add a Virtual Column with Migration

To improve performance, we’ll start by adding a virtual column for the approved_at field. This column extracts and indexes the JSON attribute for better query performance.

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration {
    public function up(): void {
        Schema::table('documents', function (Blueprint $table) {
            $table->string('approved_at')
                ->nullable()
                ->virtualAs("json_unquote(json_extract(data, '$.latest_approval_date'))");
            $table->index('approved_at');
        });
    }

    public function down(): void {
        Schema::table('documents', function (Blueprint $table) {
            $table->dropColumn('approved_at');
        });
    }
};

2. Create a Trait for Virtual Fields

We’ll create a HasVirtualFields trait to ensure that virtual fields are not mistakenly saved.

namespace App\Models\Concerns;

trait HasVirtualFields {
    public function save(array $options = []) {
        if (isset($this->virtualFields)) {
            $this->attributes = array_diff_key($this->attributes, array_flip($this->virtualFields));
        }
        return parent::save($options);
    }
}

3. Add the Trait and Virtual Column Property to Your Model

In the model, include the trait and define the virtual fields. This ensures that any virtual columns are properly managed.

use App\Models\Concerns\HasVirtualFields;

class Document extends Model {
    use HasVirtualFields;

    protected array $virtualFields = [
        'approved_at',
    ];
}

4. Testing Environment

To test the performance improvements, we’ll generate fake data and benchmark the queries before and after using virtual columns. Use the following provisioning script:

$count = 500 * 1000;
for ($i = 0; $i < 250; $i++) {
    Document::factory()->count(1000)->create();
}

6. Wrapping Up with Unit Tests

Write tests to verify that the virtual column works as expected. Here’s an example test suite:

namespace Tests\Feature\Models;

use Tests\TestCase;
use App\Models\Document;

class DocumentTest extends TestCase {
    public function testApprovedAt() {
        $date = fake()->dateTimeBetween()->format(DATE_ATOM);
        $document = Document::factory()->create([
            'data' => [
                'latest_approval_date' => $date,
            ],
        ]);
        $document->refresh();
        $this->assertEquals($date, $document->approved_at);
    }
}

This complete solution ensures that your JSON columns can be optimized for performance, particularly for large datasets.

Conclusion and Best Practices

Using virtual columns with indexing can dramatically improve performance when working with large datasets and JSON columns. By transitioning from nested JSON queries to indexed virtual columns, I was able to reduce query times by up to 36x.

Best Practices:

Use virtual columns to index frequently queried JSON attributes.
Always benchmark before and after implementing changes to measure real performance improvements.
Ensure your database structure evolves with your data as it scales, especially with JSON-heavy models.

Originally posted on bcd.dev

Cracking a coding test interview - breakdown

Babacar Cisse DIA — Tue, 28 Jan 2020 11:54:26 +0000

Cracking a coding test interview

Coding interviews are always for me an opportunity to learn and grow which is why I wanted to share you my thought process for this one I found this morning at letsrevolutionizetesting.com

What I saw when I visited the page

I revisited the application form

I wanted to know what technology was used for this

I was happy to find out it was ruby

And the hint was suggesting I should try json and I did. If you know ruby on rails then it comes to you naturally

But now I am in front of the page with this json payload. It says follow so I followed the link.
Once...

Twice...

Then I said wait...

It was too good to be true. So you have two choices:

either you go follow one by one the id chain
or you can just write a bit of function like I did

On the last page: The holy grale

You could have go for an iterative version with a loop

Wrap up

I guess at RainForest they will have to make a new test since you know the answer for this one.
Overall I think it way simple enough. We just needed to take each problem one at the time and yeah every beginner can do it too.

Supercharge your expressJs Views

Babacar Cisse DIA — Wed, 15 Jan 2020 15:36:13 +0000

Supercharge your expressJs Views

On the following few lines, I want to share with you how I added mixins to my expressjs application.

Add mixins to your views

Mix from laravel-mix (if you're from php world you know what I am saying) With laravel and mix, you're very likely to have the following snippets in your code base:

Yes this is Pug (ex jade) syntax

Explanation of express mix helper

You are most likely asking yourself where the hell this mix method is coming from so here it is.

TLDR;

  this.app.locals.mix = (filename) => {
    const fileObject = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../assets/mix-manifest.json'), 'utf8'))
    const requestedFilename = fileObject[filename]
    if (!requestedFilename) {
      throw new Error(`${filename} not found in mix manifest. Manifest: ${JSON.stringify(fileObject, null, 2)}`)
    }
    return requestedFilename
  }

I read the file outputed by webpack on build

  const fileObject = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../assets/mix-manifest.json'), 'utf8'))

then I return the value matching to the key which is the filename in our case

    const requestedFilename = fileObject[filename]
    return requestedFilename

Raise server error in case the file is not there. Should not happen but hey you never know when things can go wrong

    if (!requestedFilename) {
      throw new Error(`${filename} not found in mix manifest. Manifest: ${JSON.stringify(fileObject, null, 2)}`)
    }

Wrap up

Now you have some a nice helper function serving the latest build of webpack with a content hash to be fully efficient cache wise.
You're welcome!

# Migrate to google captcha to v3. No more "No, I am not a robot"

Babacar Cisse DIA — Fri, 10 Jan 2020 10:50:38 +0000

google captcha migration to v3. No more "No, I am not a robot"

If you did not have one, you will need to create an app here:

no more captcha. Verification happen under the hood
- before:
- after:
You can check google answer

I consider action: "contactPage", score > .8 to be a valid request. You can use your own

You can give the user ip as optional param. (I don't. Google has already enough data on us)

The front end code
The back end code
Yes I am using @laravelphp.

I also added a new page /contacted to have a better reporting from google analytics conversion for specific goals. Don't worry I protected it, you can't access it except you are coming from the contact form
Let me elaborate: Having a specific page where the user is being redirected is a good practice for analytics since you can then record the hits you are getting from that specific page (for me /contacted). You can have the same for user registration /registred

Wrap up

It was amazingly fast. The migration v2 -> v3 is straightforward. So if you did not, go ahead it is less than 5min.
Next step for me is to add it on my login form as well.
Happy coding!

Resources:

display: https://developers.google.com/recaptcha/docs/v3
verify: https://developers.google.com/recaptcha/docs/verify/