DEV Community: Oluwajubelo

Stop bleeding money on LLMs: Introducing Otellix for Go

Oluwajubelo — Sun, 29 Mar 2026 22:08:01 +0000

Working with Large Language Models (LLMs) in production is magic. The honeymoon phase usually lasts about a month—right until you get the inevitable API bill.

If you’ve ever accidentally put an LLM generation call inside a deeply nested background loop (don't lie, we've all done it), or if you just want to prevent one heavy user from eating your organization's daily budget, then you probably know the pain.

Current LLM observability platforms are either heavy SaaS products with their own per-event pricing, or they completely lack hard budget enforcement. I wanted something free, OpenTelemetry-native, and focused on hard budget limits for cost-constrained applications in Go.

So, I built Otellix.

What is Otellix?

Otellix is a production-grade LLM observability SDK for Go built entirely on top of OpenTelemetry. It wraps the official SDKs for Anthropic, OpenAI, Gemini, and Ollama, allowing you to intercept and track costs without drastically altering your codebase.

1. Unified Tracing & Metrics

Every LLM generation call emits unified OTel spans and Prometheus metrics. Wait exactly how many input tokens, output tokens, and cached tokens did that user generate last week? Otellix handles all of that out of the box, standardizing the response payloads of 4 completely different vendors.

2. Zero-Latency Cost Engine

Different LLM providers have very different pricing models depending on context-window caching. Otellix ships with an in-memory Cost Engine synced to 2026-era USD pricing models. The cost of a request is immediately available in the returning CallResult struct, meaning you deal with pennies, not abstract tokens.

res, err := otellix.Trace(ctx, cfg, provider, params)
fmt.Printf("That request cost $%.6f\n", res.CostUSD)

3. Hard Budget Guardrails

This is the core feature. What do you do when a user hits their $5/day LLM quota?
Instead of building complex Redis limiters yourself, you can plug in Otellix's BudgetEnforcer.

It ships with three fallback mechanisms:

FallbackBlock: Immediately stops the LLM execution and returns an otellix.ErrBudgetExceeded error instead of hitting the vendor API.
FallbackNotify: Allows the request to go through, but triggers an asynchronous onLimitReached callback webhook (perfect for Slack alerts).
FallbackDowngrade: (My personal favorite) If a user runs out of "premium" tokens for claude-3-opus, Otellix will automatically intercept the request and execute it via a cheaper provider/model like gemini-1.5-flash or a locally hosted ollama container instead.

Code Example

Here's how easy it is to wrap your existing OpenAI logic:

store := otellix.NewInMemoryBudgetStore(map[string]float64{
    "user_123": 2.50, // Hard limit of $2.50
})
enforcer := otellix.NewBudgetEnforcer(store, otellix.FallbackBlock, nil)

cfg := otellix.NewConfig(
    otellix.WithBudgetEnforcer(enforcer),
)

// Your existing OpenAI client logic
p, _ := openai.NewClient("sk-...") 

// Wrap the request in Otellix!
res, err := otellix.Trace(ctx, cfg, p, params)
if err != nil {
    log.Fatalf("LLM tracking failed: %v", err)
}

Getting Started

Otellix is fully open source (MIT) and available now! Oh, and the repository even includes a full docker-compose environment complete with Prometheus and Grafana dashboards for local testing.

Drop a star if you find it useful:
👉 GitHub: oluwajubelo1/otellix

I’d love to know how you're currently dealing with rogue LLM costs in your Go backends—let me know in the comments below!

Caching Strategies and Optimization in Laravel

Oluwajubelo — Tue, 26 Aug 2025 08:49:20 +0000

In today’s fast-paced digital world, speed is everything. Whether you’re building a fintech platform, an e-commerce store, or a social app, users expect instant responses. But as your application grows, database queries and heavy computations can slow things down.

That’s where caching comes into play.

Think of caching like having a photocopy of a document: instead of rewriting the entire report (expensive database query), you just pull out the copy (cached data). Much faster, right? Laravel makes this super easy with its built-in caching system.

Why Caching Matters in Laravel

Reduce database load → Expensive queries run less often.
Speed up APIs → Responses can be served in milliseconds.
Save resources → Lower CPU and memory usage, better scalability.

The result? A faster, smoother experience for your users.

Laravel Cache Drivers

Laravel supports several cache drivers (configured in config/cache.php):

File – Stores cache in files. Easy, but slower for large apps.
Database – Uses a database table for caching. Useful but can get heavy.
Redis (recommended) – Super fast, in-memory store.
Memcached – Another great option for high-performance caching.

Example setup in .env:

CACHE_DRIVER=redis

Caching Strategies in Laravel

Here are some of the most effective caching approaches you can use:

1. Cache Database Queries

Instead of running queries every time, cache the results:

$users = Cache::remember('users_list', 60, function () {
    return User::all();
});

How it works:

First request → fetches from DB, saves in cache for 60 seconds.
Next requests → served instantly from cache.

2. Cache Forever (until manually cleared)

For rarely changing data like a list of countries:

$countries = Cache::rememberForever('countries', function () {
    return Country::all();
});

Clear when necessary:

Cache::forget('countries');

3. Partial Page Caching (View Fragments)

Instead of caching entire pages, cache sections like menus, sidebars, or widgets.

@cache('sidebar_menu')
    <ul>
        @foreach($categories as $cat)
            <li>{{ $cat->name }}</li>
        @endforeach
    </ul>
@endcache

(This may need a package like Spatie’s Laravel ResponseCache.)

4. Route, Config, and View Caching

Laravel allows you to cache app configurations and routes for blazing-fast performance:

php artisan route:cache
php artisan config:cache
php artisan view:cache

Always run these in production for optimal speed.

5. Tagged Caching

When you need grouped cache that can be flushed together:

Cache::tags(['products'])->remember('featured_products', 600, function () {
    return Product::where('featured', true)->get();
});

Clear all product-related cache at once:

Cache::tags(['products'])->flush();

6. Query Caching with Eloquent

Cache paginated queries or relationship-heavy queries:

$posts = Cache::remember('posts_page_1', 120, function () {
    return Post::with('author')->paginate(10);
});

7. Cache Busting

What if cached data goes stale? Bust it whenever updates happen.

User::create([...]);
Cache::forget('users_list');

Real-World Example

Imagine a fintech dashboard that displays:

User balance
Recent transactions
Market data

Without caching:

Every request hits the DB + external APIs → slow.

With caching:

$balance = Cache::remember("balance_user_{$user->id}", 30, function () use ($user) {
    return $user->calculateBalance();
});

$transactions = Cache::remember("transactions_user_{$user->id}", 60, function () use ($user) {
    return $user->transactions()->latest()->take(10)->get();
});

$marketData = Cache::remember("market_data", 300, function () {
    return Http::get('https://api.example.com/market')->json();
});

Result:

-Balance refreshes every 30s.

Transactions refresh every 1min.
Market data refreshes every 5min.

Optimization Tips

Use Redis in production (faster than file/database caching).
Don’t over-cache—only cache expensive queries or slow computations.
Always invalidate smartly when data changes.
Combine caching with queues for heavy background tasks.
Use tools like Laravel Telescope or Debugbar to find cache opportunities.

Final Thoughts

Caching in Laravel is like giving your app superpowers. Done right, it makes your system feel lightweight, scalable, and lightning fast. The secret is knowing what to cache and when to refresh.

Think of caching as keeping photocopies of your most-used notes: instead of rewriting them every time, you just pull them out instantly.

So, if you’re serious about optimization, caching isn’t optional—it’s essential.

Caddy: The Modern Web Server That Makes HTTPS Easy

Oluwajubelo — Tue, 24 Jun 2025 09:15:14 +0000

If you're getting into web development or server administration, you've probably heard of web servers like Apache and Nginx. But there's a newer player in the game that's gaining popularity for its simplicity and powerful features: Caddy. Let's explore what makes Caddy special and how it compares to the more established Nginx.

What is Caddy?

Caddy is a modern, open-source web server written in Go. What sets it apart from traditional web servers is its focus on simplicity, automatic HTTPS, and ease of configuration. While servers like Apache and Nginx have been around for decades, Caddy was built from the ground up with modern web standards and developer experience in mind.

Think of Caddy as the "smart" web server that handles many complex tasks automatically, so you don't have to worry about them. It's particularly popular among developers who want to get a secure website up and running quickly without diving deep into server configuration.

Key Features of Caddy

Automatic HTTPS

Perhaps Caddy's most celebrated feature is its automatic HTTPS capability. When you configure a site with Caddy, it automatically obtains and renews SSL/TLS certificates from Let's Encrypt. This means your websites are encrypted by default without any manual certificate management.

Simple Configuration

Caddy uses a human-readable configuration format called the Caddyfile. Instead of complex configuration blocks, you can set up a basic website with just a few lines:

example.com {
    root * /var/www/html
    file_server
}

Built-in Features

Caddy comes with many features built-in that would require additional modules or plugins in other web servers, including reverse proxy capabilities, load balancing, and automatic gzip compression.

HTTP/2 and HTTP/3 Support

Caddy supports modern HTTP protocols out of the box, including HTTP/2 and HTTP/3 (QUIC), providing better performance for modern web applications.

Caddy vs Nginx: A Detailed Comparison

Configuration Complexity

Caddy shines with its simple, intuitive configuration. The Caddyfile format is designed to be readable by humans, not just machines. Setting up a reverse proxy or enabling HTTPS requires minimal configuration.
Nginx has a more complex configuration syntax that follows a block-based structure. While powerful and flexible, it has a steeper learning curve. Simple tasks might require more lines of configuration and deeper understanding of web server concepts.

HTTPS Setup

Caddy automatically handles SSL/TLS certificates. Just specify your domain, and Caddy takes care of obtaining, installing, and renewing certificates from Let's Encrypt.
Nginx requires manual certificate management. You need to obtain certificates separately, configure them in your Nginx configuration, and set up renewal processes. While tools like Certbot can automate this, it still requires additional setup steps.

Performance

Nginx has a proven track record for high-performance scenarios and can handle enormous amounts of concurrent connections efficiently. It's battle-tested in high-traffic environments and offers fine-grained performance tuning options.
Caddy performs well for most use cases but may not match Nginx's performance in extremely high-traffic scenarios. However, for small to medium-sized applications, the performance difference is often negligible.

Ecosystem and Plugins

Nginx has a vast ecosystem of third-party modules and extensive documentation. It's been around longer, so you'll find more tutorials, Stack Overflow answers, and community resources.
Caddy has a growing plugin ecosystem, but it's smaller than Nginx's. However, Caddy's modular architecture makes it easy to extend functionality when needed.

Resource Usage

Caddy generally uses more memory than Nginx due to its Go runtime and built-in features. However, it often requires fewer system resources overall because you don't need separate processes for certificate management and other tasks.
Nginx is known for its efficient memory usage and can run on minimal system resources, making it ideal for resource-constrained environments.

When to Choose Caddy

Caddy is an excellent choice when you want to get a secure website running quickly without complex configuration. It's particularly well-suited for developers who prioritize simplicity and automatic HTTPS. Choose Caddy if you're building modern web applications, need quick prototyping capabilities, or want to minimize server administration overhead.

When to Choose Nginx

Nginx remains the better choice for high-traffic websites that require maximum performance optimization, complex routing rules, or extensive customization. It's also preferred in enterprise environments where fine-grained control and proven scalability are essential.

Getting Started with Caddy

If you want to try Caddy, getting started is straightforward. Install it on your system, create a simple Caddyfile, and run it. Within minutes, you can have a secure website running with automatic HTTPS.

Configuration Examples

Basic Static Site (Caddy)

mysite.com {
    root * /var/www/html
    file_server
}

Basic Static Site (Nginx)

server {
    listen 80;
    server_name mysite.com;
    root /var/www/html;
    index index.html;

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

Reverse Proxy (Caddy)

api.mysite.com {
    reverse_proxy localhost:8080
}

Reverse Proxy (Nginx)

server {
    listen 80;
    server_name api.mysite.com;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Conclusion

Both Caddy and Nginx are powerful web servers, but they serve different needs. Caddy excels in simplicity and modern defaults, while Nginx offers maximum performance and flexibility. Your choice depends on your specific requirements, technical expertise, and the scale of your project.
For beginners and developers who value simplicity, Caddy offers a refreshing approach to web server management. For high-performance applications requiring extensive customization, Nginx continues to be the gold standard.
Whether you choose Caddy or Nginx, both will serve you well in your web development journey. Start with the one that matches your current needs and comfort level, and don't be afraid to explore both as you grow in your understanding of web server technologies.

Docker Multi-Stage Builds: Your Secret Weapon for Lean, Mean Container Machines

Oluwajubelo — Mon, 09 Jun 2025 08:58:13 +0000

Picture this: You've just finished building your latest web application. It's beautiful, it works perfectly, and you're ready to containerize it. You write your Dockerfile, build the image, and... it's 2GB. For a simple Node.js app. Your deployment pipeline is crying, your servers are groaning, and your wallet is getting lighter with every cloud storage bill.
Sound familiar? Welcome to the world before multi-stage builds – where Docker images were bloated with build tools, source code, and dependencies that had no business being in production.

The Problem: When Docker Images Go on a Diet (But Refuse to Lose Weight)

Let's start with a real-world scenario. You're building a React application that needs to be compiled and served by an Nginx server. Here's what your Dockerfile might look like without multi-stage builds:

dockerfile
FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
RUN npm install -g serve
EXPOSE 3000
CMD ["serve", "-s", "build"]

This approach has several problems:

Your final image includes Node.js, npm, and all development dependencies
The source code and intermediate build files are still there
The image size is unnecessarily large
You're potentially exposing security vulnerabilities through unused tools

It's like moving houses but taking all your old furniture, broken appliances, and that box of cables you'll "definitely use someday" – except in this case, you're paying for storage and bandwidth for all that digital clutter.

Enter Multi-Stage Builds: The Marie Kondo of Docker

Multi-stage builds allow you to use multiple FROM statements in your Dockerfile. Each FROM instruction starts a new build stage, and you can selectively copy artifacts from one stage to another, leaving behind everything you don't want in the final image.
Think of it as a relay race where each runner (stage) passes only what's necessary to the next runner, rather than carrying the entire team's equipment to the finish line.

Real-World Example 1: The React Application Transformation

Let's transform our bloated React app Dockerfile into a lean, multi-stage masterpiece:

dockerfile
# Stage 1: Build the application
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Stage 2: Serve the application
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

What just happened here?

Stage 1 (builder): We use Node.js to install dependencies and build our React app
Stage 2 (final): We use a lightweight Nginx image and copy only the built files

The results are dramatic:

Original image: ~1.2GB
Multi-stage image: ~25MB
That's a 98% reduction in size!

Real-World Example 2: Go Application - From Gigabytes to Megabytes

Go applications are perfect candidates for multi-stage builds because Go compiles to static binaries. Here's a typical Go web service:

dockerfile
# Stage 1: Build the Go binary
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

# Stage 2: Create minimal runtime image
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

Even better - using scratch:

dockerfile
# Stage 1: Build
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

# Stage 2: Ultra-minimal image
FROM scratch
COPY --from=builder /app/main /
EXPOSE 8080
ENTRYPOINT ["/main"]

This creates an image that's literally just your binary – we're talking about images under 10MB for most Go applications!

Real-World Example 3: Python Flask Application with Poetry

Python applications often have complex dependency management. Here's how to handle a Flask app using Poetry:

dockerfile
# Stage 1: Build dependencies
FROM python:3.11-slim AS builder
RUN pip install poetry
WORKDIR /app
COPY pyproject.toml poetry.lock ./
RUN poetry config virtualenvs.create false \
    && poetry install --only=main --no-root
COPY . .
RUN poetry build

# Stage 2: Runtime image
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /app/dist/*.whl ./
RUN pip install *.whl && rm *.whl
COPY --from=builder /app/src ./src
EXPOSE 5000
CMD ["python", "-m", "flask", "run", "--host=0.0.0.0"]

Advanced Multi-Stage Patterns

The Testing Stage Pattern

Want to run tests during your build but not include testing dependencies in your final image?

dockerfile
# Stage 1: Dependencies
FROM node:18-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci

# Stage 2: Testing
FROM deps AS testing
COPY . .
RUN npm test

# Stage 3: Build
FROM deps AS builder
COPY . .
RUN npm run build

# Stage 4: Production
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

You can then build with: docker build --target testing . to run tests, or without the target to get the production image.

The Development vs Production Pattern

dockerfile
# Base stage with common dependencies
FROM node:18-alpine AS base
WORKDIR /app
COPY package*.json ./

# Development stage
FROM base AS development
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev"]

# Production build stage
FROM base AS builder
RUN npm ci --only=production
COPY . .
RUN npm run build

# Production runtime stage
FROM nginx:alpine AS production
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Build for development: docker build --target development -t myapp:dev .
Build for production: docker build --target production -t myapp:prod .

Best Practices: Making Multi-Stage Builds Sing

Order Matters - Cache Like a Pro Put the least frequently changing layers first:

dockerfile
# Good: Dependencies change less frequently than source code
COPY package*.json ./
RUN npm install
COPY . .

# Bad: This invalidates cache for every source code change
COPY . .
RUN npm install

Use Specific Base Images

dockerfile
# Good: Explicit and smaller
FROM node:18-alpine AS builder

# Bad: Unpredictable and potentially larger
FROM node AS builder

Clean Up in the Same Layer

dockerfile
# Good: Cleanup in same layer
RUN apt-get update && \
    apt-get install -y build-essential && \
    npm install && \
    apt-get remove -y build-essential && \
    apt-get autoremove -y && \
    rm -rf /var/lib/apt/lists/*

# Bad: Each RUN creates a layer
RUN apt-get update
RUN apt-get install -y build-essential
RUN npm install
RUN apt-get remove -y build-essential

Use .dockerignore Create a .dockerignore file to prevent unnecessary files from being sent to the Docker daemon:

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
coverage
.nyc_output

Common Pitfalls and How to Avoid Them

Pitfall 1: Copying Unnecessary Files Between Stages

dockerfile
# Bad: Copying everything
COPY --from=builder /app /app

# Good: Being selective
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./

Pitfall 2: Not Using Build Arguments Effectively

dockerfile
FROM node:18-alpine AS base
ARG NODE_ENV=production
ENV NODE_ENV=$NODE_ENV

FROM base AS development
# Development-specific setup

FROM base AS production
# Production-specific setup

Build with: docker build --build-arg NODE_ENV=development --target development .

Pitfall 3: Ignoring Security in Multi-Stage Builds

dockerfile
# Good: Using non-root user
FROM alpine:latest
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
COPY --from=builder --chown=nextjs:nodejs /app/build ./build
USER nextjs

The Bottom Line

Multi-stage builds aren't just about smaller images (though that 99% size reduction is pretty sweet). They're about:

Faster deployments: Smaller images mean faster pushes and pulls
Lower costs: Less storage, less bandwidth, less money
Better security: Fewer tools in production mean fewer attack vectors
Cleaner architecture: Separation of build and runtime concerns

Multi-stage builds transform Docker from a somewhat clunky virtualization tool into a precision instrument for creating exactly the runtime environment your application needs – nothing more, nothing less.
The next time you're writing a Dockerfile, ask yourself: "What does my application actually need to run in production?" Chances are, it's a lot less than what you're currently shipping. Multi-stage builds help you ship exactly that – and your deployment pipeline will thank you for it.
Remember: In the world of containers, less is definitely more. Your future self (and your infrastructure bill) will thank you for making the switch to multi-stage builds.

Nginx for Beginners

Oluwajubelo — Mon, 19 May 2025 10:35:50 +0000

What is Nginx?

Nginx (pronounced "Engine-X") is a powerful, open-source web server software that can also function as a reverse proxy, load balancer, and HTTP cache. It’s known for its high performance, stability, and low resource usage, making it a popular choice for hosting websites and web applications.

Why Use Nginx?

Speed: Nginx is designed to handle many simultaneous connections efficiently.
Scalability: It can manage high-traffic websites with ease.
Flexibility: Works as a web server, reverse proxy, or load balancer.
Simplicity: Configuration files are straightforward and easy to understand.
Community: A large community and plenty of documentation are available.

Basic Concepts

Web Server

Nginx serves static content (like HTML, CSS, and images) to users’ browsers. It can also handle dynamic content by passing requests to application servers (e.g., those running PHP, Python, or Node.js).

Reverse Proxy

As a reverse proxy, Nginx forwards client requests to backend servers, distributing the load and improving security by hiding the backend infrastructure.

Load Balancer

Nginx can distribute incoming traffic across multiple servers to prevent any single server from becoming overwhelmed, ensuring reliability.

Configuration

Nginx uses a simple, text-based configuration file (usually nginx.conf) to define how it handles requests. This file is typically located in /etc/nginx/ on Linux systems.

Getting Started with Nginx

Installation

Here’s how to install Nginx on a Linux system (Ubuntu/Debian):

1. Update the package list:

sudo apt update

2. Install Nginx:

sudo apt install nginx

3. Start Nginx and enable it to run on boot:

sudo systemctl start nginx
sudo systemctl enable nginx

4. Verify Nginx is running by visiting `http://your_server_ip` in a browser. You should see the default Nginx welcome page.

Basic Configuration

The main configuration file is /etc/nginx/nginx.conf. A simple configuration might look like this:

http {
    server {
        listen 80;
        server_name example.com;

        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

listen 80: Nginx listens for HTTP requests on port 80.
server_name: Specifies the domain name (e.g., example.com).
location /: Defines how to handle requests to the root URL.
root: Sets the directory where website files are stored.
index: Specifies the default file to serve (e.g., index.html).

Serving a Simple Website

1. Create a directory for your website:

sudo mkdir -p /var/www/mywebsite

2. Create a basic `index.html` file:

echo "<h1>Hello from Nginx!</h1>" | sudo tee /var/www/mywebsite/index.html

3. Update the Nginx configuration (`/etc/nginx/sites-available/mywebsite`):

server {
    listen 80;
    server_name mywebsite.com;

    root /var/www/mywebsite;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }
}

4. Enable the site by linking it to `sites-enabled`:

sudo ln -s /etc/nginx/sites-available/mywebsite /etc/nginx/sites-enabled/

5. Test the configuration for errors:

sudo nginx -t

6. Reload Nginx to apply changes:

sudo systemctl reload nginx

7. Visit `http://your_server_ip` to see your “Hello from Nginx!” page.

Common Commands

Start Nginx: sudo systemctl start nginx
Stop Nginx: sudo systemctl stop nginx
Restart Nginx: sudo systemctl restart nginx
Reload Configuration: sudo systemctl reload nginx
Check Status: sudo systemctl status nginx
Test Configuration: sudo nginx -t

Laravel Queues for Beginners 🚀

Oluwajubelo — Wed, 19 Mar 2025 09:16:23 +0000

Laravel queues allow you to handle time-consuming tasks asynchronously, meaning they run in the background without slowing down your main application. This is especially useful for tasks like sending emails, processing file uploads, or handling large database operations.

📌 Why Use Queues?

1. Improves Performance

Your application doesn’t have to wait for tasks like email sending
to complete before responding.

2. Enhances User Experience

Users get immediate responses while tasks run in the background.

3. Efficient Resource Management

Heavy tasks can be processed separately, reducing the risk of timeouts.

🛠 Setting Up Laravel Queues

By default, Laravel comes with a queue system that supports different queue drivers like:

sync (Runs jobs immediately, no real queue)
database (Stores jobs in a database table)
redis (High-performance queue storage)
sqs (Amazon SQS)

1️⃣ Configure the Queue Driver
Open your .env file and set the queue driver:

QUEUE_CONNECTION=database

For Redis:

QUEUE_CONNECTION=redis

2️⃣ Create a Queue Job
Run the Artisan command to generate a job:

php artisan make:job SendWelcomeEmail

This creates a job file in app/Jobs/SendWelcomeEmail.php. Inside the handle() method, you define what the job should do.

namespace App\Jobs;

use App\Mail\WelcomeMail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Mail;

class SendWelcomeEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $user;

    public function __construct($user)
    {
        $this->user = $user;
    }

    public function handle()
    {
        Mail::to($this->user->email)->send(new WelcomeMail($this->user));
    }
}

📝 Key Points:

ShouldQueue tells Laravel to process this job asynchronously.
handle() contains the logic for sending the email.

3️⃣ Dispatching a Job
You can dispatch the job from anywhere in your application:

dispatch(new SendWelcomeEmail($user));

Or use the dispatch() helper:

SendWelcomeEmail::dispatch($user);

For a delay:

SendWelcomeEmail::dispatch($user)->delay(now()->addMinutes(5));

4️⃣ Processing the Queue
Before running jobs, you must start the queue worker:

php artisan queue:work

This will continuously process new jobs in the queue.

For database queues, you need to create the table:

php artisan queue:table
php artisan migrate

If you want the worker to restart automatically after crashes, use:

php artisan queue:restart

🔧 Queue Management Tips

Retry Failed Jobs – If a job fails, you can retry it:

php artisan queue:retry all

Monitor Jobs – Use Horizon for Redis-based queues:

php artisan horizon

🎯 Conclusion
Laravel queues make your application faster and more responsive by handling heavy tasks in the background. Start simple with database queues, then move to Redis or SQS for better scalability.

Understanding Cron Jobs in Laravel

Oluwajubelo — Tue, 11 Mar 2025 15:42:23 +0000

Imagine you own a poultry farm 🐔, and every morning at exactly 6 AM, you need to feed your chickens automatically. You don’t want to wake up early every day to do it manually. So, you buy an automatic feeder that dispenses food at 6 AM on its own.

In Laravel, a cron job is like your automatic feeder. It allows you to schedule tasks that should run automatically at a specific time.

Why Do You Need a Cron Job?
Let's say you are running an e-commerce website 🛒, and you want to send a reminder email to customers every day at 9 AM about items left in their cart. Instead of sending these emails manually, you can create a Laravel cron job that handles it automatically.

How to Set Up a Cron Job in Laravel

Step 1: Create a Laravel Command

Laravel provides a way to define scheduled tasks using artisan commands. To create a new command, run:

php artisan make:command SendCartReminderEmails

This will generate a file inside app/Console/Commands/ named SendCartReminderEmails.php.

Step 2: Define the Command’s Logic

Open the file app/Console/Commands/SendCartReminderEmails.php, and you will see a handle() method. This is where you define what should happen when the command runs.

Modify the handle() method like this:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use App\Models\User;
use App\Mail\CartReminderMail;
use Illuminate\Support\Facades\Mail;

class SendCartReminderEmails extends Command
{
    protected $signature = 'email:cart-reminder'; // Command name
    protected $description = 'Send reminder emails to users about items in their cart';

    public function __construct()
    {
        parent::__construct();
    }

    public function handle()
    {
        $users = User::whereHas('cart')->get(); // Get users with items in their cart

        foreach ($users as $user) {
            Mail::to($user->email)->send(new CartReminderMail($user));
        }

        $this->info('Cart reminder emails sent successfully!');
    }
}

Step 3: Schedule the Command in Kernel

Now that we have our command, we need to tell Laravel when it should run.

Open app/Console/Kernel.php and inside the schedule() method, add:

protected function schedule(Schedule $schedule)
{
    $schedule->command('email:cart-reminder')->dailyAt('09:00'); // Runs every day at 9 AM
}

Here are other ways you can schedule a job:

Step 4: Register Laravel's Scheduler in Crontab

Laravel’s scheduler does not run on its own. You need to register it in your server’s crontab (a list of scheduled tasks for Linux).

Run:

crontab -e

Then add this line at the bottom:

* * * * * php /path-to-your-project/artisan schedule:run >> /dev/null 2>&1

🔹 Explanation:

* * * * * → Runs the Laravel scheduler every minute
php /path-to-your-project/artisan schedule:run → Runs Laravel's scheduled tasks
>> /dev/null 2>&1 → Hides output (optional)

Step 5: Test the Cron Job Manually

Before waiting for it to run automatically, you can test it by running:

php artisan schedule:run

If everything is set up correctly, Laravel will execute the job immediately.

Final Thoughts

Just like how your automatic chicken feeder makes your life easier, cron jobs in Laravel help automate repetitive tasks like sending emails, clearing old records, or updating reports.

So now, instead of manually reminding users about their abandoned carts, your Laravel application will automatically do it for you every morning at 9 AM—just like clockwork! 🕘🔔

Would you like help setting up cron jobs for other use cases? 😊

Strategies for Optimizing MySQL Database Performance: A Case Study of Class54

Oluwajubelo — Wed, 19 Feb 2025 09:09:32 +0000

Optimizing Class54 Database to Handle Hundreds of Thousands of Records Without Latency

Managing a database to handle extensive data processing efficiently can be a daunting task, especially when dealing with hundreds of thousands of records. This was precisely the challenge we faced with the Class54 database, which served as the backbone of our application. Its inefficiencies in handling large data sets led to significant latency issues, hampering performance and user experience. Here, I will share how we identified the problems, implemented solutions, and achieved optimal performance for our system.

The Problem
Class54, a test preparation platform, provides resources for major Nigerian exams, including JAMB, WAEC, and POST-UTME of 36 major Nigerian schools. The platform hosts JAMB past questions from the year 2000 to 2024 and WAEC past questions from the same range. Initially designed to support a modest number of users, the platform grew exponentially, and so did the database’s workload. The core database, built on MySQL, started experiencing severe performance degradation when processing larger volumes of data. Tasks like fetching records for analytical dashboards, generating reports, or executing bulk updates took an unacceptably long time to complete.

The following symptoms were observed:

1. Slow Query Execution:

Some queries took several seconds or even minutes to execute.

2. High CPU Utilization:

The database server frequently reached its CPU usage limits during peak hours.

3. Locking and Deadlocks:

Concurrent operations led to frequent table locking, delaying processes and sometimes causing application crashes.

4. Inefficient Indexing:

Tables had either too many indexes or poorly optimized ones, leading to increased storage usage and query latency.

5. Scalability Issues:

The current design could not efficiently scale to handle the growing dataset without considerable cost.

Diagnosis

To address the issue, a thorough analysis of the database was conducted. This involved:

1. Query Profiling:

Using MySQL’s EXPLAIN and SHOW PROFILE commands, we identified slow-performing queries and analyzed their execution plans.

2. Schema Review:

A detailed review of the database schema highlighted unnecessary indexes, redundant columns, and inefficient table designs.

3. Workload Analysis:

Tools like MySQL Workbench and monitoring utilities (such as Prometheus and Grafana) were used to analyze the workload patterns and identify bottlenecks.

4. Concurrency Testing:

Simulated concurrent user interactions helped uncover locking issues and inefficiencies in handling parallel requests.

The Solution

Armed with insights from our analysis, we implemented the following strategies to optimize the Class54 database:

1. Index Optimization

Indexes are vital for speeding up queries, but poorly designed indexes can be counterproductive. We:

Removed redundant and unused indexes.
Created composite indexes to optimize queries filtering on multiple
columns.
Reordered columns in indexes to match query patterns, ensuring
maximum efficiency.

2. Database Normalization and Denormalization

While normalization ensures data consistency, over-normalization can lead to excessive joins, slowing down queries. We:

Normalized tables to reduce redundancy where feasible.
Denormalized heavily accessed tables by introducing summary tables for frequently aggregated data, reducing join operations.

3. Query Optimization

We rewrote inefficient queries and:

Replaced SELECT * with explicit column selection to minimize data
transfer.
Used batch processing for bulk operations to avoid locking large
datasets.
Introduced pagination for fetching records in chunks rather than
loading everything at once.

4. Partitioning Large Tables

To manage large tables efficiently, we implemented horizontal partitioning:

Split large tables into smaller, more manageable partitions based
on logical divisions (e.g., date ranges or user regions).
Queries were adjusted to target specific partitions, significantly
reducing scan times.

5. Caching Frequently Accessed Data

To reduce the load on the database:

Implemented an in-memory cache using Redis for frequently accessed,
read-heavy data.
Used query caching for recurring analytical queries, significantly
speeding up response times.

6. Connection Pooling and Load Balancing

Efficient connection management was ensured by:

Implementing connection pooling to reuse database connections,
reducing overhead from frequent opening and closing of connections.
Setting up read replicas for load balancing, directing read-heavy
operations to replicas while keeping writes on the primary node.

7. Migration to a Cloud-Native Database Architecture

To future-proof the system:

Migrated the database to a cloud-native managed service, taking
advantage of features like auto-scaling and read replicas.
Introduced a data warehouse for heavy analytical workloads,
separating transactional and analytical processing.

Results

After these optimizations, the Class54 database achieved the following improvements:

1. Reduced Query Latency:

Average query execution time dropped from 10-15 seconds to under 200 milliseconds for most queries.

2. Improved Scalability:

The database comfortably handled peak loads with over 500,000
records, and its architecture allowed seamless scaling as data
volumes grew.

3. Lower CPU Usage:

Optimized queries and indexing significantly reduced CPU utilization, freeing up resources for other processes.

4. Enhanced User Experience:

Faster query responses and smoother application performance led to increased user satisfaction and retention.

5. Significant Cost Reduction:

Beyond the performance gains, these optimizations also translated into tangible cost savings. For instance, optimizing the student code generation function, which previously relied on inefficient parent::pluck('student_code') calls, drastically reduced the load on our Digital Ocean droplets. This single improvement, combined with the other database optimizations, allowed us to downsize our droplet configuration, resulting in a substantial reduction in our monthly infrastructure expenses. This demonstrates our commitment to both performance and cost-efficiency.

Lessons Learned

1. Proactive Monitoring:

Regularly monitoring and profiling database performance can help identify issues before they escalate.

2. Iterative Optimization:

Database optimization is an ongoing process that evolves with application requirements.

3. Balancing Normalization and Denormalization:

Striking the right balance is crucial for maintaining data integrity and performance.

4. Investing in Automation:

Using automated tools for indexing suggestions and query optimization can save considerable time and effort.

Conclusion

Optimizing the Class54 database was a challenging but rewarding experience. By combining careful analysis, strategic indexing, query optimization, and leveraging cloud-native solutions, we transformed the database into a high-performing, scalable component of our platform. These lessons and approaches can be applied to other database systems facing similar challenges, ensuring efficient handling of large datasets without compromising performance.

Taming Entropy in GoLang Codebases

Oluwajubelo — Thu, 13 Feb 2025 12:51:26 +0000

What is Entropy?
Entropy at its core is the degree of how "chaotic" or "unorganized" a system is, therefore, the higher the entropy, the higher the chaos and disorder.

What is Entropy in Software Design?
In the context of software development, entropy refers to the gradual accumulation of disorder and complexity within a codebase or system over time. The disorder arises for severa factors which will include:

Ad hoc changes: Unplanned or poorly thought-out modifications.
Poor coding practices: Inconsistent styles, lack of documentation, and absence of meaningful structure.
Complexity Creep: As systems evolve, dependencies, edge cases, and special requirements add layers of complexity.
Lack of testing: Bugs accumulate due to untested or poorly maintained code.
Technical debt: Quick fixes and shortcuts taken to meet deadlines lead to degraded code quality.
Team scaling: Larger teams may lead to inconsistent approaches and styles if not governed by strong guidelines.
Organic Growth: Codebases often grow organically, with features layered over existing code rather than planned holistically.
Lack of Standards: Without coding guidelines or architectural principles, individual developers may implement solutions inconsistently.
Neglected Maintenance: Over time, code that isn't refactored or reviewed tends to degrade.

Over time, high entropy in a software system can manifest as:

Hard-to-read and poorly structured code.
Increased likelihood of bugs and regressions.
Difficulty in onboarding new developers.
Longer development and debugging cycles.
Scalability issues and reduced performance.

The Impact of Entropy in Software Design

Reduced Agility: Adding new features becomes increasingly challenging due to the tangled codebase
Higher Costs: Debugging, refactoring, and scaling a disorganized system require significant resources.
Team Frustration: Developers may feel demotivated working in a chaotic environment.
System Instability: Frequent bugs and downtime in production systems.

How can we manage and reduce Entropy in our codebases?
We need to adopt strategies that maintain order and consistency, and these might include:

Adhering to Coding Standards: Use tools like linters, formatters, and style guides.
Implementing Clear Architecture: Modular and well-defined components reduce interdependence.
Regular Refactoring: Continuously improve code quality to adapt to new requirements without introducing chaos.
Testing: Comprehensive testing prevents regressions and provides a safety net for changes.
Documentation: Clear documentation reduces uncertainty for future contributors.

Now let’s talk about how to apply these strategies in Go codebases to enable us tame the chaos proactively.

1. The Foundation: Coding Standards

Why it matters: Uniform coding practices make a codebase
predictable and easier to read.
- Tools:
  - gofmt: The gofmt package is used for automatic formatting of the codebase, this makes it such that all collaborators have a consistently formatted code, increasing readability.
  Before gofmt:

After gofmt:

golint: provides feedback on Go code, focusing on the style and best practices rather than functional correctness or runtime behavior. It flags potential issues that deviates from Go's conventions.

2. Organizing Packages and Code

The problem: Spaghetti package structures increase coupling and reduce maintainability.
Solution:
- Emphasize clear, single-responsibility packages.
- Use meaningful directory names and adhere to Go's "package-first" approach.
- Avoid circular dependencies by thinking in terms of layers or domains.
Most modern Go codebase use the hexagonal architecture, which encourages several patterns to make maintainability and scalability easier. I attempts to solve very common issues experienced by Go developers.

3. Interface-Driven Design

Concept: Define behaviors with interfaces and let
implementations evolve independently.
Benefits:
Easier testing with mock interfaces.
Decouples high-level modules from low-level details.
Example: A Storage interface and its implementations
(Cloudinary, Aws S3, etc.).

4. Dependency Injection Done Right

What is it? Injecting dependencies instead of hard-coding them
to make components reusable and testable.
Approaches in Go:
Constructor injection.
Use DI libraries sparingly (e.g., Uber’s fx).
Example: Injecting the storage interface we created earlier
into a file uploader service. This makes it possible for any of the
storage interface implementations to be used in the UploadFile
function

5. Testing as a First-Class Citizen

The importance of tests: Tests document your code, validate
behavior, and prevent regressions.
Best Practices:
- Write unit tests for core logic.
- Use table-driven tests to make them concise and readable.
- Incorporate integration tests for end-to-end behavior.
- Tools like go test and mockgen.
Example: Using mockgen to generate a mock for our storage

service, then using the mocked storage in our test.

Conclusion

Key Takeaways:

Consistent Coding: Use gofmt and golint to enforce coding
standards.
Clear Structure: Organise packages logically to reduce
complexity.
Interface-Driven Design: Decouple components with small
interfaces.
Dependency Injection: Pass dependencies explicitly to improve
testability.
Comprehensive Testing: Regularly test code to maintain its
quality.

These principles, applied consistently, will help you keep your Go codebase organised, scalable, and chaos-free.

Thank you for reading. Remember, reducing entropy is a continuous process. By applying these strategies, you can keep your Go codebase clean and maintainable over time🙂

How to Install Composer

Oluwajubelo — Mon, 27 Jan 2025 08:38:22 +0000

Composer is a dependency management tool for PHP. It helps developers manage libraries and packages their projects depend on. Instead of manually downloading and updating third-party PHP libraries, Composer automates the process, ensuring your project gets the correct versions and updates when needed.

Why Use Composer?

Saves Time: It eliminates the need to manually download and integrate libraries.
Ensures Compatibility: Handles dependency conflicts and ensures libraries work together.
Simplifies Updates: Allows you to easily update libraries when new versions are available.
Boosts Collaboration: Other developers on your team can simply run composer install to get all dependencies defined in the composer.json.

Install Composer on Windows
Step 1: Download Composer Installer

1. Go to the official Composer website:

  https://getcomposer.org/

2.

Click on "Getting Started" and then download the "Composer-Setup.exe" file for Windows.

Step 2: Run the Installer

1. Open the downloaded `Composer-Setup.exe` file.

Follow the installation wizard:

Choose PHP Executable: Locate your php.exe file. If PHP is
installed and added to your PATH, the installer will detect it
automatically.
If PHP is not installed, download it from php.net or install
tools like XAMPP or WAMP.
Select Installation Path: Choose the folder where Composer
should be installed.
Add Composer to PATH: The installer will offer to add
Composer to your system's PATH automatically. Ensure this option
is selected.

Step 3: Verify the Installation

1. Open Command Prompt or PowerShell.

2. Type:

composer --version

If Composer is installed successfully, it will display the version.

Install Composer on macOS

Step 1: Install Homebrew (Optional)

If you don’t have Homebrew installed, you can install it first. Homebrew is a package manager for macOS.

1. Open the terminal and run:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Verify Homebrew installation:

brew --version

Step 2: Install Composer

1. Open the terminal and run the following commands to download

and install Composer:
Step 2.1: Download Composer installer:

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

Step 2.2: Verify the installer (optional):

php -r "if (hash_file('sha384', 'composer-setup.php') === file_get_contents('https://composer.github.io/installer.sig')) { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Step 2.3: Install Composer:

php composer-setup.php

Step 2.4: Remove the installer file:

php -r "unlink('composer-setup.php');"

2. Move the composer binary to make it globally accessible:

sudo mv composer.phar /usr/local/bin/composer

Step 3: Verify the Installation

Open the terminal and type:

composer --version

If Composer is installed successfully, it will display the version.

Alternative (Using Homebrew)

If you have Homebrew, you can install Composer directly:

1. Run:

brew install composer

2. Verify the installation:

composer --version

Functions in PHP

Oluwajubelo — Wed, 22 Jan 2025 15:50:21 +0000

What is a Function in PHP?

A function in PHP is a block of reusable code designed to perform a specific task. It allows for modular programming, improves code readability, and reduces repetition. Think of a function as a way to handle repetitive tasks efficiently. Instead of going through the hassle of rewriting the same code every time you need to perform a task, you create a function once and simply call it whenever needed, saving time and effort.

Functions are generally categorized into user-defined functions and built-in functions. Here's a closer look at each type:

1. Built-in Functions

These are predefined functions provided by PHP. They are ready to use and cover a wide range of tasks, such as string manipulation, array handling, mathematical operations, and working with files.

Features:

They come with PHP and require no additional coding.
Highly optimized for performance.
Wide variety available for almost every common task.

Examples:

echo strtoupper("hello"); // Outputs: HELLO
echo strlen("PHP"); // Outputs: 3

2. User-defined Functions

These are functions created by developers to solve specific problems or perform custom tasks. They are especially useful for tasks that need to be repeated or require unique logic not covered by built-in functions.

Features:

Written by the developer to meet specific needs.
Improve code reusability and organization.
Can take parameters, return values, and include custom logic.

Examples:

function isAdult($age) {
    return $age >= 18 ? "Adult" : "Minor";
}

echo isAdult(16); // Outputs: Minor

function add($a, $b) {
    return $a + $b;
}

echo add(5, 10); // Outputs: 15

Best Practices When Writing Functions in PHP
Writing clean, efficient, and reusable functions is crucial for creating maintainable and scalable code. Here are some best practices to follow:

1. Choose Descriptive Names

Function names should clearly indicate what the function does.
Use camelCase or snake_case naming conventions consistently.

function calculateTotalPrice($items) {
    // Code here
}

2. Keep Functions Small and Focused

A function should perform one specific task.
If a function becomes too long or does too many things, consider
breaking it into smaller functions.

function getUserData($userId) {
    // Fetch user data from the database
}

function validateUserData($userData) {
    // Validate the fetched data
}

3. Use Parameters and Arguments Thoughtfully

Pass parameters to functions instead of relying on global
variables.
Set default values for optional parameters.

function sendEmail($recipient, $subject = "No Subject") {
    // Email sending logic
}

4. Return Values Instead of Printing Directly

Avoid directly printing data inside a function. Instead, return the value and let the calling code handle output.

function calculateDiscount($price, $discount) {
    return $price - ($price * $discount / 100);
}

echo calculateDiscount(100, 10); // Outputs: 90

5. Avoid Hardcoding Values

Use constants or configuration files instead of hardcoding values within a function.

define("DEFAULT_DISCOUNT", 10);

function applyDiscount($price, $discount = DEFAULT_DISCOUNT) {
    return $price - ($price * $discount / 100);
}

Introduction to PHP

Oluwajubelo — Mon, 13 Jan 2025 15:04:42 +0000

I'll be writing about the series of events we're conducting in the TechHaven Mentorship Program for Backend Engineers here. This being the first week, we walked through how to install PHP and VSCode (Visual Studio Code) on Windows and macOS systems.

For Windows Users
Step 1: Download XAMPP

Visit this website to download: https://www.apachefriends.org.
Choose the XAMPP version that supports PHP 8.2. Look for entries
like XAMPP for PHP 8.2.x.
Click the download link for your preferred version (Windows).
Save the installer file to your computer.

Step 2: Install XAMPP

Run the Installer:
Navigate to the folder where you downloaded the XAMPP installer (e.g., xampp-windows-x64-8.2.x-installer.exe).

Double-click the installer to start the setup process.

Choose Installation Components:

During the setup wizard, select the components you want to install. By default, essential components like Apache, MySQL, PHP, and phpMyAdmin are selected. Ensure PHP and phpMyAdmin are checked.
Click Next to proceed

Select Installation Folder:

Choose the folder where you want to install XAMPP (default is
C:\xampp). You can change this if needed.
Click Next.

Start Installation:

Click Next to confirm your choices and start the installation.
Wait for the installation process to complete. This may take a few
minutes.

Finish Installation:

Once the installation is done, you’ll see a confirmation screen. Check the box to launch the XAMPP Control Panel and click Finish.

Step 3: Configure and Verify Installation

Open XAMPP Control Panel:

Launch the XAMPP Control Panel from your Start Menu or the installation directory.

Start Apache and MySQL:

In the control panel, click Start next to Apache and MySQL.
Ensure both services turn green, indicating they’re running.

Verify PHP Version:

Open a browser and navigate to http://localhost/dashboard.
To verify PHP 8.2 is installed, create a phpinfo.php file:

Navigate to C:\xampp\htdocs.
Create a new file named phpinfo.php and add the following
content:

<?php
    phpinfo();
 ?>

Open your browser and go to http://localhost/phpinfo.php
You should see PHP 8.2 listed in the output.

Step 4: Add PHP to System PATH (Optional)

Access Environment Variables:

Press Win + S, type Environment Variables, and select Edit the system environment variables.
In the System Properties window, click Environment Variables.

Add PHP Path:

Under System Variables, find the Path variable and click Edit.
Click New and add the path to the PHP folder, e.g., C:\xampp\php.

Save Changes:

Click OK to save and close all windows.
Restart your system and open your terminal, then type php -v , you should see something like this as response

PHP 8.2.0 (cli) (built: Nov 29 2023 12:00:00) ( ZTS Visual C++ 2019 x64 )
Copyright (c) The PHP Group
Zend Engine v4.2.0, Copyright (c) Zend Technologies

For MacOS users:

Older macOS versions (prior to macOS Monterey) include PHP by default. However, the version might be outdated.
Checking if PHP is Installed: Open the Terminal (Command + Space, type Terminal, and hit Enter) and run:

php -v

If PHP is installed, this will show the PHP version.
If not, you’ll get a message like command not found.

If PHP is Not Installed
If your Mac does not have PHP (common in newer macOS versions), you can easily install it using tools like Homebrew.

Installing PHP Using Homebrew

Install Homebrew (if not already installed): Open Terminal and run:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Install PHP: Run the following command to install the latest version of PHP:

brew install php

if you want to install a specific version of PHP, use this command

brew install php@version

Verify Installation: After installation, verify the PHP version:

php -v

Add PHP to PATH (if needed): Homebrew automatically adds PHP to your PATH, but if it doesn't work, add the following line to your ~/.zshrc file (for Zsh shell, default on macOS):

 export PATH="/usr/local/opt/php@<version>/bin:$PATH"

Then reload your shell configuration:

source ~/.zshrc  # or source ~/.bash_profile

To install MySQL, follow commands below

Install the MySQL package:

brew install mysql

if you want to install a specific version of PHP, use this command

brew install mysql@version

Once installation is complete, start the MySQL service:

brew services start mysql

Verify MySQL Installation:

Check the MySQL version to confirm installation:

mysql --version

Example output:

mysql  Ver 8.0.x for osx on x86_64 (Homebrew)

mysql -u root -p

Stop/Restart MySQL Service (Optional):

To stop the MySQL service:

brew services stop mysql

To restart the MySQL service:

brew services restart mysql

Configure PATH (if necessary)

Add the MySQL binary to your PATH (if not automatically added). Open your shell configuration file (e.g., ~/.zshrc or ~/.bash_profile) and add:

export PATH="/usr/local/opt/mysql/bin:$PATH"

Reload the shell configuration:

source ~/.zshrc  # or source ~/.bash_profile

To Install VSCode on your system, kindly follow the steps below:
Step 1: Download the Installer

Visit the official VS Code website.
Click the Download for Windows/MacOS button. This will download the appropriate installer for your system.

Step 2: Run the Installer

Locate the downloaded file (e.g., VSCodeSetup-x64-.exe for windows users, .dmg file for macos users) and double-click to run it.
Follow the installation wizard:

Accept the license agreement.
Choose the installation location (default is fine for most users).
Select additional options, such as:

Adding VS Code to your system PATH (recommended).
Creating a desktop shortcut.

Step 3: Launch VS Code

Once the installation is complete, open VS Code by clicking the shortcut or searching for "Visual Studio Code" in the Start menu.

For MacOS users:
After downloading the .dmg file
Step 2: Install VS Code

Open the downloaded .dmg file.
Drag and drop the Visual Studio Code icon into the Applications folder.

Step 3: Add VS Code to PATH (Optional)
To use VS Code from the terminal:

Open VS Code.
Press Cmd + Shift + P to open the Command Palette.
Type Shell Command: Install 'code' command in PATH and select it.
Restart your terminal and verify by typing:

code

DEV Community: Oluwajubelo

Stop bleeding money on LLMs: Introducing Otellix for Go

What is Otellix?

1. Unified Tracing & Metrics

2. Zero-Latency Cost Engine

3. Hard Budget Guardrails

Code Example

Getting Started

Caching Strategies and Optimization in Laravel

Why Caching Matters in Laravel

Laravel Cache Drivers

Caching Strategies in Laravel

1. Cache Database Queries

2. Cache Forever (until manually cleared)

3. Partial Page Caching (View Fragments)

4. Route, Config, and View Caching

5. Tagged Caching

6. Query Caching with Eloquent

7. Cache Busting

Optimization Tips

Final Thoughts

Caddy: The Modern Web Server That Makes HTTPS Easy

What is Caddy?

Key Features of Caddy

Automatic HTTPS

Simple Configuration

Built-in Features

HTTP/2 and HTTP/3 Support

Caddy vs Nginx: A Detailed Comparison

Configuration Complexity

HTTPS Setup

Performance

Ecosystem and Plugins

Resource Usage

When to Choose Caddy

When to Choose Nginx

Getting Started with Caddy

Configuration Examples

Basic Static Site (Caddy)

Basic Static Site (Nginx)

Reverse Proxy (Caddy)

Reverse Proxy (Nginx)

Conclusion

Docker Multi-Stage Builds: Your Secret Weapon for Lean, Mean Container Machines

The Problem: When Docker Images Go on a Diet (But Refuse to Lose Weight)

Enter Multi-Stage Builds: The Marie Kondo of Docker

Real-World Example 1: The React Application Transformation

What just happened here?

The results are dramatic:

Real-World Example 2: Go Application - From Gigabytes to Megabytes

Even better - using scratch:

Real-World Example 3: Python Flask Application with Poetry

Advanced Multi-Stage Patterns

The Testing Stage Pattern

The Development vs Production Pattern

Best Practices: Making Multi-Stage Builds Sing

Common Pitfalls and How to Avoid Them

Pitfall 1: Copying Unnecessary Files Between Stages

Pitfall 2: Not Using Build Arguments Effectively

Pitfall 3: Ignoring Security in Multi-Stage Builds

The Bottom Line

Nginx for Beginners

What is Nginx?

Why Use Nginx?

Basic Concepts

Web Server

Reverse Proxy

Load Balancer

Configuration

Getting Started with Nginx

Installation

1. Update the package list:

2. Install Nginx:

3. Start Nginx and enable it to run on boot:

4. Verify Nginx is running by visiting http://your_server_ip in a browser. You should see the default Nginx welcome page.

Basic Configuration

Serving a Simple Website

1. Create a directory for your website:

2. Create a basic index.html file:

3. Update the Nginx configuration (/etc/nginx/sites-available/mywebsite):

4. Verify Nginx is running by visiting `http://your_server_ip` in a browser. You should see the default Nginx welcome page.

2. Create a basic `index.html` file:

3. Update the Nginx configuration (`/etc/nginx/sites-available/mywebsite`):

4. Enable the site by linking it to `sites-enabled`:

7. Visit `http://your_server_ip` to see your “Hello from Nginx!” page.

1. Open the downloaded `Composer-Setup.exe` file.