Forem: Christian Paez

The case for boring tools

Christian Paez — Sun, 08 Mar 2026 22:18:57 +0000

Many of us software developers spend time on personal projects. Mine was/is a simple personal tech blog. When I first built it, I wanted to stick to the tools I was most used to:

React.js
Some SSR metaframework (Next or Gatsby)
A JavaScript build system (Webpack back then)

And that is what I did. I took a template for Ghost CMS and built a basic blog for fun.

After writing for a couple of months and having updated my site over 50 times, I began to get small problems.

1. Writing became boring

The way the CMS worked was by taking markdown content, adding some metadata to it like canonical links, metatags, etc., storing this info in a database (yes, this needed a server), and then triggering a build on the server-side rendered site. This meant that after the fun part of writing my little blog post, I had to go to an admin panel, log in, figure out all the metatags and attributes for my blog post, and fill out a massive form with a good amount of form validation (description cannot be longer than x, title is too short, etc.), just to trigger a build and wait a couple of minutes to see my blog post. I remember many times spending more time publishing the post than actually writing it.

2. This setup is not simple

If I go to Medium, Quora, or Substack, I can just take markdown, an image, and some tags and be ready to post a blog. This was not what my blog had, and I began to notice that my setup was too complex. Since I was probably used to complications at work, I did not see this until a couple of months of writing. Also, running this blog locally was annoying since dependencies were always broken for some reason, as most JavaScript projects are.

3. It costs more than needed

At first, this was not a problem because the golden years of free Heroku dynos were still a thing. But when they nuked their free tier, I noticed that I was running a server with a database when I just needed to serve static content.

So after a while, writing became boring. I lost my admin panel credentials and forgot about the site.

Boring just works

One day I was browsing for web templates since I wanted a blog for non-tech content and stumbled upon Jekyll. It is a super basic static site generator that has:

No database
No admin panel
No JS pipeline

It is true that it does not do a lot of the fancy SSR, IWR, SCG, and other permutations of letters I can't understand (I made some of those up, and you probably did not notice). But I could write a .md file and get a blog post in less than a minute. It took me longer to log in to my admin panel and find the "Create Post" button on the page than just having my site updated.

So now:

To publish a blog post, I spend 90% writing and 10% making the post available online
I understand how my simple setup works
I don't have unnecessary costs

I even use Jekyll for some other projects that are non-blog sites, and it's so nice to have something simple that does not break and does not cause friction. I know there has to be a case for a more sophisticated setup but for now I like to keep it simple.

Boring but works.

The Ultimate SQL JOIN Cheat Sheet

Christian Paez — Tue, 10 Sep 2024 15:36:45 +0000

If you're working with relational databases, you'll often need to combine data from multiple tables. SQL JOINs help you achieve this.

Understanding INNER JOIN

An INNER JOIN retrieves rows where there is a match between the tables based on the specified join condition. If no match is found, no rows are returned for that combination.

The syntax for an INNER JOIN looks like this:

-- [Mandatory] SELECT: Specifies the columns you want to retrieve.
SELECT
    -- [Optional] DISTINCT: Ensures the result set contains only unique rows by removing duplicates.
    -- Place DISTINCT immediately after SELECT if you want only unique rows.
    -- DISTINCT 
    column1, -- Specify the first column you want to retrieve
    column2, -- Specify the second column, and so on...
    ...

-- [Mandatory] FROM: The table from which you're selecting data.
FROM
    table1

-- [Mandatory] INNER JOIN: Joins two tables and retrieves rows that have matching values in both tables.
INNER JOIN
    table2 -- The second table you're joining with the first table

-- [Mandatory] ON: Specifies the condition that defines how the tables are related. 
-- Only rows where the columns match will be included in the result set.
ON
    table1.column = table2.column

-- [Optional] WHERE: Filters the rows returned by the join based on a specific condition.
-- Only rows that meet this condition will be included in the final result.
-- WHERE condition

-- [Optional] ORDER BY: Sorts the result set by the specified columns.
-- You can choose to sort in ascending (ASC) or descending (DESC) order.
-- ORDER BY column1 [ASC|DESC], column2 [ASC|DESC];

Understanding OUTER JOINs

While INNER JOINs return only matching rows between two tables, OUTER JOINs go further by also including rows that do not have a match in one of the tables. There are three types of OUTER JOINs:

LEFT OUTER JOIN (or simply LEFT JOIN): returns all rows from the left table and the matching rows from the right table. If no match is found, the result will contain NULL for the columns from the right table.
RIGHT OUTER JOIN (or simply RIGHT JOIN): works in the opposite way of a LEFT JOIN. It returns all rows from the right table and the matching rows from the left table. If no match is found, the result will contain NULL for the columns from the left table.
FULL OUTER JOIN: returns all rows when there is a match in either the left or right table. If there is no match, the result will contain NULL for the columns from the table without a match.

Each of these joins is useful depending on the specific data retrieval needs.

The syntax for an OUTER JOIN looks like this:

-- [Mandatory] SELECT: Specifies the columns you want to retrieve.
SELECT
    -- [Optional] DISTINCT: Ensures the result set contains only unique rows by removing duplicates.
    -- Place DISTINCT immediately after SELECT if you want only unique rows.
    -- DISTINCT 
    column1, -- Specify the first column you want to retrieve
    column2, -- Specify the second column, and so on...
    ...

-- [Mandatory] FROM: The table from which you're selecting data.
FROM
    table1

-- [Mandatory] OUTER JOIN: Includes rows from the specified table even if there is no match in the other table.
-- You can use LEFT OUTER JOIN, RIGHT OUTER JOIN, or FULL OUTER JOIN based on your needs.
-- LEFT OUTER JOIN: Includes all rows from the left table and matched rows from the right table.
-- RIGHT OUTER JOIN: Includes all rows from the right table and matched rows from the left table.
-- FULL OUTER JOIN: Includes all rows from both tables, with NULLs where there is no match.
-- Example: LEFT OUTER JOIN
    LEFT OUTER JOIN
    table2 -- The table you're joining with the first table

-- [Mandatory] ON: Specifies the condition that defines how the tables are related. 
-- Only rows where the columns match will be included in the result set, or all rows from one table depending on the join type.
ON
    table1.column = table2.column

-- [Optional] WHERE: Filters the rows returned by the join based on a specific condition.
-- Only rows that meet this condition will be included in the final result.
-- WHERE condition

-- [Optional] ORDER BY: Sorts the result set by the specified columns.
-- You can choose to sort in ascending (ASC) or descending (DESC) order.
-- ORDER BY column1 [ASC|DESC], column2 [ASC|DESC];

Example of INNER JOIN

To retrieve employee names and their associated department names, where there is a matching department for each employee, you can use an INNER JOIN:

SELECT
    employees.employee_name,
    departments.department_name
FROM
    employees
INNER JOIN
    departments
ON
    employees.department_id = departments.department_id;

This query will return only the rows where there is a match between the department_id columns in both the employees and departments tables. If an employee does not have a corresponding department or a department has no employees, those rows will not appear in the result set.

Example of LEFT OUTER JOIN

Let’s say we have an employees table and a departments table, and we want to retrieve all employees, even if they are not assigned to a department:

SELECT
    employees.employee_name,
    departments.department_name
FROM
    employees
LEFT OUTER JOIN
    departments
ON
    employees.department_id = departments.department_id;

In this example, the query will return all rows from the employees table, and if an employee does not belong to a department, the department_name will show as NULL.

Example of RIGHT OUTER JOIN

Let’s modify our previous example to retrieve all departments, even if they don’t have any employees assigned:

SELECT
    employees.employee_name,
    departments.department_name
FROM
    employees
RIGHT OUTER JOIN
    departments
ON
    employees.department_id = departments.department_id;

This query will return all rows from the departments table, and if a department doesn’t have any employees, the employee_name will show as NULL.

Example of FULL OUTER JOIN

To retrieve all employees and all departments, including those that don’t have a match in the other table, you can use a FULL OUTER JOIN:

SELECT
    employees.employee_name,
    departments.department_name
FROM
    employees
FULL OUTER JOIN
    departments
ON
    employees.department_id = departments.department_id;

This query will return all rows from both tables. If an employee is not assigned to a department, department_name will be NULL. If a department has no employees, employee_name will be NULL.

Example: LEFT OUTER JOIN with WHERE and ORDER BY

Here’s a query that retrieves all employees (even those without a department) and filters the results to only include employees from specific departments. The result is sorted in ascending order by employee name.

SELECT
    DISTINCT employees.employee_name,
    departments.department_name
FROM
    employees

LEFT OUTER JOIN
    departments
ON
    employees.department_id = departments.department_id
WHERE
    departments.department_name IN ('Sales', 'HR')

ORDER BY
    employees.employee_name ASC;

Happy querying!

HackerRank SQL Preparation: Weather Observation Station 3(MySQL)

Christian Paez — Tue, 27 Aug 2024 01:41:25 +0000

Problem Statement:
Query a list of CITY names from STATION for cities that have an even ID number. Print the results in any order, but exclude duplicates from the answer.

Link: HackerRank - Weather Observation Station 3

Solution:

SELECT DISTINCT CITY FROM STATION WHERE ID % 2 = 0;

Explanation:

SELECT DISTINCT CITY: This part of the query specifies that you want to retrieve the CITY column from the STATION table, and DISTINCT ensures that each city name is unique, eliminating any duplicates from the result.
FROM STATION: Indicates that you are selecting data from the STATION table.
WHERE ID % 2 = 0: This condition filters the rows to include only those cities where the ID is an even number. The modulo operation (% 2 = 0) checks if the ID is divisible by 2, meaning it's even.

This query will return a list of unique city names from the STATION table where the city has an even ID number. The result will exclude any duplicate city names.

HackerRank SQL Preparation: Weather Observation Station 1(MySQL)

Christian Paez — Sun, 09 Jun 2024 18:31:33 +0000

Problem Statement:
Query a list of CITY and STATE from the STATION table.

Link: HackerRank - Weather Observation Station 1

Solution:

SELECT CITY, STATE FROM STATION;

Explanation:

SELECT CITY, STATE: This part of the query specifies that you want to retrieve the CITY and STATE columns from the STATION table.
FROM STATION: Indicates that you are selecting data from the STATION table.

HackerRank SQL Preparation: Japanese Cities' Names(MySQL)

Christian Paez — Sun, 09 Jun 2024 18:24:42 +0000

Problem Statement:
Query the names of all Japanese cities in the CITY table. The COUNTRYCODE for Japan is JPN.

Link: HackerRank - Japanese Cities Name

Solution:

SELECT NAME FROM CITY WHERE COUNTRYCODE = 'JPN';

Explanation:

SELECT NAME: This part of the query specifies that you want to retrieve the NAME column from the CITY table.
FROM CITY: Indicates that you are selecting data from the CITY table.
WHERE COUNTRYCODE = 'JPN': This condition filters the rows to include only those cities where the COUNTRYCODE is 'JPN' (Japan).

HackerRank SQL Preparation: Japanese Cities' Attributes(MySQL)

Christian Paez — Thu, 06 Jun 2024 14:18:07 +0000

Problem Statement:
Query all attributes of every Japanese city in the CITY table. The COUNTRYCODE for Japan is JPN.

Link: HackerRank - Japanese Cities Attributes

Solution:

SELECT * FROM CITY WHERE COUNTRYCODE = 'JPN';

Explanation:

SELECT *: The asterisk (*) is a wildcard character in SQL that means "all columns." This part of the query specifies that you want to retrieve all columns from the table.
FROM CITY: Indicates that you are selecting data from the CITY table.
WHERE COUNTRYCODE = 'JPN': This condition filters the rows to include only the cities where the COUNTRYCODE is 'JPN' (Japan).

This query will return all the columns for every row in the CITY table where the COUNTRYCODE is 'JPN'. It's useful when you need to retrieve all details about every city in Japan.

By running this query, you can see the complete dataset of Japanese cities stored in the CITY table, including information such as city names, populations, districts, and other relevant attributes.

HackerRank SQL Preparation: Select by ID(MySQL)

Christian Paez — Thu, 06 Jun 2024 14:07:20 +0000

Problem Statement:
Query all columns for a city in the CITY table with the ID 1661.

Link: HackerRank - Select by ID

Solution:

SELECT * FROM CITY WHERE ID = 1661;

Explanation:

SELECT *: The asterisk (*) is a wildcard character in SQL that means "all columns." This part of the query specifies that you want to retrieve all columns from the table.
FROM CITY: Indicates that you are selecting data from the CITY table.
WHERE ID = 1661: This condition filters the rows to include only the city with the specific ID of 1661.

This query will return all the columns for the row in the CITY table where the ID is 1661. It's useful when you need to retrieve all details about a specific city identified by its unique ID.

By running this query, you can see all the attributes (such as city name, country code, population, etc.) for the city that has the ID of 1661.

HackerRank SQL Preparation: Select All(MySQL)

Christian Paez — Thu, 06 Jun 2024 13:57:03 +0000

Problem Statement:
Query all columns (attributes) for every row in the CITY table.

Link: HackerRank - Select All SQL

Solution:

SELECT * FROM CITY;

Explanation:

SELECT *: The asterisk (*) is a wildcard character in SQL that means "all columns." This part of the query specifies that you want to retrieve all columns from the table.
FROM CITY: Indicates that you are selecting data from the CITY table.

This query will return all the columns for every row in the CITY table. It's useful when you need to inspect or analyze all data available in the table without any specific filtering or conditions.

Automate binary execution at Startup with BASH

Christian Paez — Wed, 22 May 2024 20:41:26 +0000

Automating the startup of frequently used binaries can save time and streamline your workflow. This blog post introduces a simple Bash script that adds specified binaries to a function that executes them every time you start your computer.

Benefits of Automating Program Execution at Startup:

Efficiency: Automating the startup of commonly used programs reduces manual steps and ensures your environment is ready with minimal effort.
Consistency: Ensures that necessary programs and scripts are always running without the need to remember and manually start them each time.
Productivity: Frees up mental bandwidth, allowing you to focus on your tasks rather than setting up your environment every time you boot your computer.
Learning: Writing and modifying Bash scripts enhances your scripting skills and deepens your understanding of system startup processes.

The Script:

Our Bash script automates the process of executing binaries when our system starts, we made a function that takes a list of binaries and executes them, this will be added to your .bashrc file:

function startup() {
    BINARIES=(
         "/usr/bin/firefox"
         "/usr/bin/code")

    check_binary() {
        local binary=$1
        if [ -x "$binary" ]; then
            echo "Found binary: $binary, executing..."
            "$binary" & disown
        else
            echo "Binary not found or not executable: $binary"
        fi
    }

    for binary in "${BINARIES[@]}"; do
        check_binary "$binary"
    done
}

Instructions for Using the Script:

After you boot up your system, just type the function name in a terminal:

startup

You can also execute a gist that adds the function automatically to your .bashrc file, you can then modify the BINARIES and use the function on system boot up:

curl -L https://artofcode.tech/add-startup-function | bash

Simplifying PATH Management with Bash

Christian Paez — Tue, 07 May 2024 03:39:12 +0000

In the world of command-line, every keystroke counts. One essential aspect of this efficiency is managing your system's PATH variable. A well-managed PATH ensures easy access to frequently used scripts and executables. In this blog post, we introduce a simple Bash script that streamlines the process of adding directories to your PATH, along with instructions on how to use it with curl.

Benefits of Writing Your Own Scripts and Adding Them to PATH:

Efficiency: Writing custom scripts allows you to automate repetitive tasks and tailor them to your specific needs. By adding them to your PATH, you can execute them from anywhere in your terminal without specifying their full path.
Consistency: Adding scripts to your PATH ensures consistency across your system. You don't have to remember the exact location of each script; they're readily available for execution.
Flexibility: With scripts in your PATH, you have the flexibility to create your own command-line utilities tailored to your workflow. Whether it's simplifying complex commands or automating system tasks, the possibilities are endless.
Knowledge Enhancement: Writing Bash scripts enhances your understanding of shell scripting and Linux systems. You'll learn about variables, loops, conditionals, and other fundamental concepts, empowering you to create more sophisticated scripts in the future.

Brief Description of the Script:

Our Bash script automates the process of adding directories to your PATH variable in the .bashrc file. It takes the current directory you are in and adds it to the PATH in your .bashrc file.

#!/bin/bash

# Function to add current directory to PATH in .bashrc file
add_current_dir_to_path() {
    # Get the current directory
    local current_dir=$(pwd)

    # Print the current directory
    echo "Current directory: $current_dir"

    local shell_config=".bashrc"

    # Check if the directory is already in PATH
    if [[ ":$PATH:" == *":$current_dir:"* ]]; then
        echo "Current directory is already in PATH."
    else
        # Check if PATH variable is empty
        if [ -z "$PATH" ]; then
            # If PATH is empty, directly append the current directory
            echo "export PATH=$current_dir" >> "$HOME/$shell_config"
        else
            # Append the current directory to the PATH variable
            echo "export PATH=\\$PATH:$current_dir" >> "$HOME/$shell_config"
        fi
        echo "Current directory added to PATH in $shell_config."
        echo "Remember to execute 'source $shell_config' to update the PATH."
    fi
}

# Call the function 
add_current_dir_to_path

Instructions for Using with curl:

To use the script with curl, simply run the following command in your terminal:

curl -L https://artofcode.tech/add-path | bash

Automating Video editing with programming knowledge

Christian Paez — Sat, 13 Apr 2024 19:03:16 +0000

Many video editing tasks can be repetitive and time-consuming, especially when applied frequently across different videos. While professional software like Adobe After Effects offer scripting tools for automation, developers who prefer a streamlined approach without the need to open heavy software can turn to Python and OpenCV. In this blog post, we'll explore how to enhance videos by adding opacity transitions at the start and end using Python and OpenCV.

Basic Functionalities of OpenCV:

OpenCV is a popular library used for computer vision and image
processing tasks. It provides a wide range of functionalities. In this blog post, we'll focus on leveraging OpenCV's video editing capabilities to add opacity transitions to a video.

Adding Opacity Transitions with Python and OpenCV:
To add opacity transitions to a video, we'll follow these steps:

Setting Up the Project: Import the necessary libraries (cv2, numpy, tqdm) and define the input and output video paths.
Reading the Input Video: Use OpenCV to read the input video and retrieve its properties such as frame width, height, frame rate, and total frame count.
Adding Opacity Transitions: Calculate opacity levels for the start and end transitions and apply them to the video frames using OpenCV's image manipulation functions.
Writing the Output Video: Create a new video file and write the edited frames with opacity transitions using OpenCV's VideoWriter class.
Displaying Progress and Messages: Use the tqdm library to create a progress bar and print informative messages during video processing.

Here's the complete Python script for adding opacity transitions to a video using Python and OpenCV:

import cv2
import numpy as np
from tqdm import tqdm

input_video_path = 'input_video.mp4'
output_video_path = 'output_video.mp4'

cap = cv2.VideoCapture(input_video_path)

if not cap.isOpened():
    print("Error: Could not open video file.")
    exit()

frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
fps = int(cap.get(5))
frame_count = int(cap.get(7))

fade_frames = 15  # Number of frames for the opacity transition

fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))

with tqdm(total=frame_count) as pbar:
    for i in range(frame_count):
        ret, frame = cap.read()

        if not ret:
            break

        # Calculate opacity for the start and end transitions
        start_alpha = min(1.0, i / fade_frames)
        end_alpha = min(1.0, (frame_count - i) / fade_frames)

        # Apply opacity transitions
        frame = cv2.addWeighted(frame, start_alpha, frame, 0, 0)
        frame = cv2.addWeighted(frame, end_alpha, frame, 0, 0)

        out.write(frame)
        pbar.update(1)

cap.release()
out.release()
cv2.destroyAllWindows()

print("Video processing completed.")

The result looks something like this:

https://www.youtube.com/shorts/Pbb1FYdNdlc

Experiment with the provided script, adjust parameters, and explore additional video editing functionalities offered by OpenCV to take your video editing skills to the next level.

HackerRank SQL preparation; Revising the Select Query II(MySQL)

Christian Paez — Wed, 03 Apr 2024 21:59:56 +0000

Problem Statement:
Query the NAME field for American cities in the CITY table with populations larger than 120,000. The CountryCode for America is USA.

Link:HackerRank - Revising the SELECT Query 2

Solution:

SELECT NAME FROM CITY WHERE POPULATION > 120000 AND COUNTRYCODE = 'USA';

Explanation:

SELECT NAME: This part of the query specifies that you want to retrieve the NAME field.
FROM CITY: Indicates that you are selecting data from the CITY table.
WHERE POPULATION > 120000: This condition filters the rows and includes only those cities where the population is larger than 120,000.
AND COUNTRYCODE = 'USA': This additional condition ensures that only American cities (USA) are included in the result, based on the CountryCode column.