DEV Community: Siswoyo Siswoyo

Apache JMeter – Overview and Practical Guide

Siswoyo Siswoyo — Wed, 17 Dec 2025 07:15:33 +0000

What is Apache JMeter?

Apache JMeter is an open‑source performance and load testing tool written in Java. It is widely used to test the performance, scalability, and reliability of applications such as web apps, APIs, microservices, databases, and messaging systems. JMeter simulates real user traffic by generating concurrent requests and measuring how the system behaves under different loads.

Originally designed for web applications, JMeter has evolved into a full‑featured testing platform supporting REST, SOAP, JDBC, FTP, TCP, JMS, Kafka (via plugins), and more.

Why Use JMeter?

Open Source & Free – No licensing cost
Cross‑Platform – Runs on Windows, macOS, and Linux
Highly Extensible – Large ecosystem of plugins
Scalable Testing – Supports distributed (master–slave) testing
CI/CD Friendly – Can be run in headless (CLI) mode

Common Use Cases

Load testing REST and SOAP APIs
Stress testing e‑commerce applications
Performance testing microservices
Database performance testing (JDBC)
Message queue testing (RabbitMQ, Kafka, JMS)
Regression performance testing before release

Core JMeter Concepts

1. Test Plan

A Test Plan is the top‑level container that defines:

What to test
How many users to simulate
How requests are executed
What data to collect

2. Thread Group (Virtual Users)

A Thread Group represents virtual users (threads).
Key parameters:

Number of Threads (Users) – Total concurrent users
Ramp‑Up Period (seconds) – Time to start all users
Loop Count – How many times each user runs the test

Example:

Users: 100
Ramp‑up: 10 seconds → ~10 users start per second

3. Sampler

A Sampler defines the actual request sent to the server.
Common samplers:

HTTP Request (REST, Web)
JDBC Request (Database)
JMS Publisher / Subscriber
TCP Sampler

4. Config Elements

Used to define shared configuration:

HTTP Request Defaults
HTTP Header Manager
CSV Data Set Config (for test data)
User Defined Variables

5. Timers

Timers control delays between requests:

Constant Timer
Uniform Random Timer
Gaussian Random Timer

Used to simulate real user behavior.

6. Assertions

Assertions validate responses:

Response code (200, 201, etc.)
Response body contains expected text
JSON / XPath assertions

Assertions help ensure correctness, not just speed.

7. Listeners

Listeners collect and display test results:

View Results Tree (debugging)
Summary Report
Aggregate Report
Response Time Graph

⚠️ Avoid heavy listeners during large tests.

Key Performance Metrics in JMeter

Load Time – Total time to complete the request
Connect Time – Time to establish connection
Latency – Time until first byte is received
Throughput – Requests per second
Error Rate – Percentage of failed requests
Response Size – Bytes sent/received

These metrics help identify bottlenecks.

Example: E‑Commerce Load Test Scenario

Scenario:

User browses product list
User views product detail
User adds item to cart
User checks out

Thread Group Strategy:

10 users (baseline)
50 users (normal load)
100 users (peak load)
500 users (stress test)

Assertions:

HTTP 200 on browse
Cart response contains product ID
Checkout returns order ID

Running JMeter Tests

GUI Mode (Development Only)

Used for:

Creating test plans
Debugging requests

Non‑GUI Mode (Production / CI)

Recommended for load testing:

jmeter -n -t test.jmx -l result.jtl

Benefits:

Lower memory usage
Faster execution
CI/CD compatible

Best Practices

Use CSV files for test data (users, tokens)
Disable heavy listeners for large loads
Run JMeter in non‑GUI mode for real tests
Monitor server resources (CPU, memory, DB)
Start with small load, increase gradually
Separate functional testing from performance testing

Limitations of JMeter

Not a browser (no real JavaScript rendering)
High load requires tuning or distributed setup
GUI mode consumes high memory

For frontend performance, combine with tools like browser‑based testing.

Conclusion

Apache JMeter is a powerful and flexible tool for performance testing. When used correctly, it helps teams understand system limits, prevent production failures, and improve application reliability. It is especially effective for API‑based systems, microservices, and backend performance validation.

Reference: https://jmeter.apache.org/

Install ISPConfig with Nginx Webserver on Ubuntu 22.04

Siswoyo Siswoyo — Tue, 04 Nov 2025 04:08:03 +0000

Introduction

ISPConfig is a very popular open‑source hosting control panel that lets
you manage websites, email accounts, DNS records, FTP, and more. Using
Nginx as the web server is typically more performant than Apache for
many scenarios (especially static content, reverse‑proxying etc). This
guide shows how to install ISPConfig 3 + Nginx on Ubuntu 22.04, starting
from a fresh system.

Important: This setup assumes a fresh, clean OS install with
minimal/no prior custom configuration. Doing this on a server with
many existing services/configs may lead to conflicts.
(howtoforge.com)

Prerequisites

Before you begin: - A server running Ubuntu 22.04 (64‑bit) with internet
access. - A hostname set correctly (see below). - A public IP address,
reachable, DNS configured (so your hostname resolves). - Ports such as
HTTP (80), HTTPS (443), and the ISPConfig panel port (8080) must not be
blocked. - You'll be logged in as root (or using sudo). - The OS should
be essentially "clean" (no major services already installed or
customised that the auto‑installer will clobber).

Step 1: Log in to the server

sudo -s

Step 2: Configure the hostname and hosts file

Pick a fully qualified domain name (FQDN) for your server such as
server1.example.com. Do not just use example.com.

Edit /etc/hosts:

nano /etc/hosts

and ensure you have a line like:

127.0.1.1   server1.example.com   server1

Edit /etc/hostname:
```
nano /etc/hostname
```
Put only the short hostname (e.g., server1).
Reboot the server:
```
systemctl reboot
```
After reboot, verify:
```
hostname
hostname -f
```
Ensure your DNS provider has an A (and/or AAAA) record for

server1.example.com pointing to your server's public IP.

Step 3: Update the system

apt update && apt upgrade -y

Step 4: Run the auto‑installer for ISPConfig with Nginx

Now is the key part: installing ISPConfig and choosing Nginx as the web
server.

wget -O - https://get.ispconfig.org | sh -s -- --use-nginx --use-ftp-ports=40110-40210 --unattended-upgrades

What the arguments mean

--use-nginx → use Nginx instead of Apache.
--use-ftp-ports=40110-40210 → set passive FTP port range for Pure‑FTPd.
--unattended-upgrades → enables automatic updates/upgrades.

After installation completes

You'll see the generated passwords, e.g.:

[INFO] Your ISPConfig admin password is: <password>
[INFO] Your MySQL root password is: <password>

Ensure you record these.

Step 5: Setting up the firewall

Allow necessary ports through UFW or within ISPConfig UI → System →
Firewall.

TCP ports:

20,21,22,25,80,443,40110:40210,110,143,465,587,993,995,53,8080,8081

UDP:

Step 6: Finalizing

Log into ISPConfig panel:

https://server1.example.com:8080

Step 7: Adding Your Website

Once you are inside the ISPConfig panel, you can start adding new
websites under Sites → Add new site.

Before you add a website: - Ensure your domain name (e.g.,
example.com) is already pointing to your server's public IP
address. - You can check your DNS propagation and record setup using
https://dnschecker.org/.

If your domain is not yet propagated or pointing to the correct IP, the
site might not load correctly.

Steps to add a site:

Go to Sites → Add new website.
Enter your domain name (e.g., example.com).
Choose the IP address of your server (you can leave it as * if you want ISPConfig to use all available IPs).
Set PHP version, SSL (Let's Encrypt), and other options.
Save your configuration.

After saving, ISPConfig will create the Nginx virtual host configuration
automatically.

Step 8: Advanced options

--channel=<stable|dev> → choose branch
--lang=en|de → choose language
--use-php=7.4,8.1 → install specific PHP versions
--no-mail → skip mail server
--no-dns → skip DNS server
--debug → detailed log in /tmp/ispconfig-ai/var/log/ispconfig.log

Example for minimal install:

wget -O - https://get.ispconfig.org | sh -s -- --use-nginx --no-dns --no-mail --use-ftp-ports=40110-40210 --unattended-upgrades

Step 9: Troubleshooting

Rerun with --debug if installation fails.
Check /tmp/ispconfig-ai/var/log/ispconfig.log for details.
Ensure fresh OS install to avoid config conflicts.

Summary

You can now manage websites, email, DNS, databases, and FTP through
ISPConfig 3 with Nginx on Ubuntu 22.04.

Before adding sites, make sure your domain and public IP setup are
verified using DNSChecker.org.

Reference:

The `tree` Command in Ubuntu

Siswoyo Siswoyo — Fri, 10 Oct 2025 08:30:57 +0000

📌 Introduction

The tree command in Ubuntu is a powerful utility that displays the contents of directories in a tree-like structure. Instead of listing files and directories in a flat list (like ls does), it visually represents the hierarchy of directories, making it easier to understand the structure of a file system.

This is especially useful for:

Viewing project structures
Exploring configuration files
Understanding nested directories at a glance

📥 Installation

By default, tree may not be installed on Ubuntu. You can install it using:

sudo apt update
sudo apt install tree -y

To confirm installation:

tree --version

📂 Basic Usage

1. Display current directory structure

   tree

2. Show full path of files and directories

   tree -f

3. Limit depth of directory tree

   tree -L 2

(This shows only two levels deep.)

4. Show hidden files (dotfiles)

   tree -a

5. Print size of files

   tree -s

🎯 Common Options

Option	Description
`-a`	Show all files including hidden ones
`-d`	List directories only
`-L n`	Limit depth of directory tree to `n` levels
`-f`	Print full path for each file
`-s`	Show file size in bytes
`-h`	Show file size in human-readable format
`--du`	Show cumulative directory sizes
`-P`	List only files matching a pattern
`-I`	Exclude files matching a pattern

🔍 Examples

1. Display only directories up to 3 levels

   tree -d -L 3

2. Show file sizes in human-readable format

   tree -h

3. Exclude specific directories (e.g., .git)

   tree -I ".git"

4. Display project structure

   tree -L 2 -I "node_modules"

📑 Example Output

If you run tree -L 2 inside a project folder, you may get:

.
├── README.md
├── package.json
├── public
│   ├── index.html
│   └── favicon.ico
└── src
    ├── App.js
    ├── index.js
    └── components

✅ Conclusion

The tree command in Ubuntu is an essential tool for visualizing directory structures. With its various options, it allows developers, system administrators, and everyday users to quickly understand and navigate complex file systems.

Reference: https://manpages.ubuntu.com/manpages/jammy/man1/tree.1.html

Control Your Android on PC with Vysor

Siswoyo Siswoyo — Wed, 10 Sep 2025 05:03:50 +0000

Managing your Android device directly from your PC can greatly improve productivity, especially if you’re multitasking between your phone and computer. Vysor is a powerful tool that lets you mirror and control your Android device from your Windows, macOS, Linux, or even Chrome browser.

What is Vysor?

Vysor is a screen mirroring application developed by Koushik Dutta. It allows you to:

View your Android screen on your PC.
Control your phone using your keyboard and mouse.
Take screenshots and record your screen.
Drag and drop files between your PC and Android device (Pro feature).

It’s especially useful for developers, customer support agents, or anyone who wants to interact with their phone without constantly switching devices.

Key Features

Simple Setup – Install the app on both your PC and Android device and connect via USB or Wi-Fi.
Cross-Platform Support – Works on Windows, macOS, Linux, and even Chrome.
Keyboard & Mouse Control – Type messages, play games, and navigate apps seamlessly.
File Sharing – Drag and drop files (Pro version).
Screen Recording – Record your Android screen directly from your PC.

How to Use Vysor

1. Install Vysor

Download and install Vysor on your PC from the official website: https://www.vysor.io.
Install the Vysor app from the Google Play Store on your Android device.

2. Install ADB Drivers (Windows Users)

To let your PC communicate with your Android phone, you need ADB (Android Debug Bridge) drivers.

Download the Universal ADB Driver: https://adb.clockworkmod.com
Run the installer and follow the on-screen instructions.
Once installed, reconnect your Android device via USB.
Your PC should now recognize the phone when using Vysor.

💡 Note for Mac/Linux users: You don’t need to install extra drivers; ADB works out of the box.

3. Enable USB Debugging

On your Android device, go to Settings > About Phone > Tap “Build Number” 7 times to enable Developer Options.
Go to Settings > Developer Options > Enable USB Debugging.
Confirm the USB Debugging prompt when connecting your device to the PC.

4. Connect Your Device

Plug your Android device into your PC using a USB cable (Wi-Fi connection available in the Pro version).
Open Vysor on your PC, and your device should appear in the list.
Click View to start mirroring your Android screen.

Android

5. Control Your Device

Use your keyboard to type messages.
Navigate apps with your mouse.
Enjoy seamless control without constantly switching between devices.

Free vs Pro

Free version: Includes screen mirroring and basic controls with ads.
Pro version: Removes ads, adds Wi-Fi connectivity, full-screen mode, drag-and-drop, and HD quality.
You can check the latest pricing and subscription options here: Vysor Pricing – around $2.50/mo, $10/yr, or $40 lifetime as listed on their site.

Benefits of Using Vysor

✅ Boosts productivity for developers and office users.
✅ Easy for tech support to guide customers remotely.
✅ Great for presentations and demos.
✅ Makes mobile gaming easier on a larger screen.

References

👉 With Vysor + ADB drivers, you can fully control your Android from your PC with ease. Perfect for work, support, or entertainment.

Homelab: A Complete Overview

Siswoyo Siswoyo — Tue, 02 Sep 2025 16:33:01 +0000

📌 What is a Homelab?

A homelab is a personal environment where you experiment with technology, servers, and networking outside of production systems. It’s commonly used by IT enthusiasts, developers, and system administrators to learn, test, and self-host services at home.

Homelabs can range from a simple single-PC setup to a rack of enterprise-grade servers.

🎯 Why Build a Homelab?

Learning & Experimentation Practice new technologies like Docker, Kubernetes, virtualization, and networking.
Skill Development Gain hands-on experience for IT certifications and real-world problem-solving.
Self-Hosting Run your own cloud services such as Nextcloud, media servers, VPN, or password managers.
Automation Practice Experiment with tools like Ansible, Terraform, and CI/CD pipelines.
Cost Savings Repurpose old hardware instead of relying on expensive cloud providers.

🛠️ Common Homelab Components

1. Hardware

Old desktop PCs or laptops
Mini PCs (Intel NUC, Raspberry Pi)
Used enterprise servers (Dell PowerEdge, HP ProLiant)
Network equipment (routers, switches, firewalls)

2. Virtualization & Containers

Proxmox – open-source virtualization
VMware ESXi – enterprise-grade hypervisor
Docker – container platform for apps
Kubernetes / K3s – container orchestration

3. Networking

VLANs, VPNs, firewalls
Pi-hole for DNS-level ad blocking
pfSense or OPNsense for routing & security

4. Services to Run

Media servers: Plex, Jellyfin
File storage: Nextcloud, Syncthing
DevOps tools: GitLab, Jenkins
Monitoring: Grafana, Prometheus
Home automation: Home Assistant

🧑‍💻 Example Homelab Setup

Server: Old Dell PowerEdge with 32GB RAM
Virtualization: Proxmox for managing VMs
Containers: Docker running Nextcloud, Plex, Grafana
Network: pfSense firewall + Pi-hole DNS
Storage: RAID-configured NAS for backups

⚡ Tips for Building Your Homelab

Start small – repurpose an old laptop or Raspberry Pi.
Document everything – keep notes on configs and setups.
Use automation – learn Ansible/Terraform to manage infrastructure.
Backup frequently – test disaster recovery.
Keep it secure – use strong passwords, VPN, and firewalls.

📚 Resources to Get Started

✅ A homelab is not just a playground—it’s a personal cloud, learning lab, and automation hub.

Transaction Numbers in a System

Siswoyo Siswoyo — Mon, 01 Sep 2025 18:11:43 +0000

When designing a system that handles financial or operational transactions (e.g., orders, invoices, payments, shipments), one of the most important considerations is how transaction numbers are generated and managed.

Why Transaction Numbers Are Important

Uniqueness → Every transaction must be identifiable without confusion.
Traceability → Makes it easy to track and audit transactions.
Integration → When multiple services or systems are involved, transaction numbers must remain consistent.
User Reference → Customers and staff often need a simple reference number for communication.

Common Approaches to Transaction Numbers

1. Auto-Increment Serial (Sequential Numbers)

Example: TRX-000001, TRX-000002, TRX-000003
Pros:
- Simple and human-friendly.
- Easy to track the count of transactions.
Cons:
- Hard to merge across multiple systems (risk of duplicate numbers).
- Predictable numbers can expose business volume.

2. UUID (Universally Unique Identifier)

Example: d290f1ee-6c54-4b01-90e6-d701748f0851
Pros:
- Guaranteed uniqueness across systems and services.
- No collision issues when merging data.
Cons:
- Not user-friendly.
- Longer to store and index in databases.

3. Hybrid Format (Prefix + Date + Sequence / UUID)

Example: INV-20250819-0012 or PAY-2025-08-19-XYZ123
Pros:
- Human-readable with context (date, type).
- Sequence helps ordering within a day.
- Can still incorporate randomness or UUID for uniqueness.
Cons:
- Slightly more complex to implement.

Recommended Practice

For internal system identifiers: use UUIDs to ensure uniqueness, especially in distributed or microservice architectures.
For user-facing transaction numbers: generate a readable sequence with prefixes and dates (e.g., ORD-20250819-0456).
Store both values:
- Primary Key / Internal ID → UUID
- Public Transaction Number → Sequential or Hybrid format

Example: Dual Identifier Approach

Field	Example Value	Purpose
`transaction_id` (UUID)	`a9c3b5f4-2e4b-4ef9-a2af...`	Internal system reference
`transaction_no`	`ORD-20250819-0456`	User-facing, easy to reference

This way, the system remains scalable, merge-friendly, and user-friendly.

SQL Schema Example

Below is a PostgreSQL example showing how to implement this approach:

CREATE TABLE transactions (
    transaction_id UUID PRIMARY KEY DEFAULT gen_random_uuid(), -- Internal unique ID
    transaction_no VARCHAR(50) UNIQUE NOT NULL,                -- Public transaction number
    transaction_type VARCHAR(20) NOT NULL,                     -- e.g. ORDER, PAYMENT, INVOICE
    transaction_date TIMESTAMP NOT NULL DEFAULT NOW(),
    customer_id UUID NOT NULL,
    amount NUMERIC(12,2) NOT NULL,
    status VARCHAR(20) NOT NULL DEFAULT 'PENDING'
);

-- Example: Insert with a generated transaction number
INSERT INTO transactions (transaction_no, transaction_type, customer_id, amount)
VALUES (
    CONCAT('ORD-', TO_CHAR(NOW(), 'YYYYMMDD'), '-', LPAD(nextval('transaction_seq')::TEXT, 4, '0')),
    'ORDER',
    '550e8400-e29b-41d4-a716-446655440000',
    150000.00
);

-- Sequence for daily increment
CREATE SEQUENCE transaction_seq START 1;

-- Example: Insert with a generated transaction number
INSERT INTO transactions (transaction_no, transaction_type, customer_id, amount)
VALUES (
    CONCAT('ORD-', TO_CHAR(NOW(), 'YYYYMMDD'), '-', LPAD(nextval('transaction_seq')::TEXT, 4, '0')),
    'ORDER',
    '550e8400-e29b-41d4-a716-446655440000',
    150000.00
);

Relationships with Other Tables

When designing related tables, always use transaction_id (UUID) as the foreign key.
Each related table should also have its own unique reference number (payment_no, shipment_no).

Payments Table

CREATE TABLE payments (
    payment_id UUID PRIMARY KEY DEFAULT gen_random_uuid(), -- Internal unique ID
    payment_no VARCHAR(50) UNIQUE NOT NULL,                -- Public payment number
    transaction_id UUID NOT NULL REFERENCES transactions(transaction_id) ON DELETE CASCADE,
    payment_date TIMESTAMP NOT NULL DEFAULT NOW(),
    payment_method VARCHAR(50) NOT NULL,
    amount NUMERIC(12,2) NOT NULL
);

-- Sequence for payments
CREATE SEQUENCE payment_seq START 1;

-- Example insert
INSERT INTO payments (payment_no, transaction_id, payment_method, amount)
VALUES (
    CONCAT('PAY-', TO_CHAR(NOW(), 'YYYYMMDD'), '-', LPAD(nextval('payment_seq')::TEXT, 4, '0')),
    'a9c3b5f4-2e4b-4ef9-a2af-123456789abc',
    'CREDIT_CARD',
    150000.00
);

Shipments Table

CREATE TABLE shipments (
    shipment_id UUID PRIMARY KEY DEFAULT gen_random_uuid(), -- Internal unique ID
    shipment_no VARCHAR(50) UNIQUE NOT NULL,                -- Public shipment number
    transaction_id UUID NOT NULL REFERENCES transactions(transaction_id) ON DELETE CASCADE,
    courier VARCHAR(50) NOT NULL,
    tracking_no VARCHAR(100),
    shipped_date TIMESTAMP
);

-- Sequence for shipments
CREATE SEQUENCE shipment_seq START 1;

-- Example insert
INSERT INTO shipments (shipment_no, transaction_id, courier, tracking_no, shipped_date)
VALUES (
    CONCAT('SHP-', TO_CHAR(NOW(), 'YYYYMMDD'), '-', LPAD(nextval('shipment_seq')::TEXT, 4, '0')),
    'a9c3b5f4-2e4b-4ef9-a2af-123456789abc',
    'DHL',
    'DHL123456789',
    NOW()
);

Why Use UUID for Relations but Public Numbers for Reference?

UUID (transaction_id, payment_id, shipment_id) → Used for database relations, stable and permanent.
Public numbers (transaction_no, payment_no, shipment_no) → Used for communication with users, human-friendly, and can include business context (prefix, date, sequence).
This ensures data integrity inside the system while providing clear references outside the system.

How to Create a Bootable USB Windows 10 Using Rufus

Siswoyo Siswoyo — Wed, 27 Aug 2025 16:44:36 +0000

Creating a bootable USB drive is one of the easiest and most reliable ways to install or reinstall Windows 10. With the help of Rufus, a lightweight and free utility, you can prepare a USB stick to install Windows quickly.

✅ What You Need

Before starting, make sure you have the following:

A USB flash drive (at least 8 GB in size).
A Windows 10 ISO file (you can download it from the Microsoft website).
The latest version of Rufus (download here).

🔧 Steps to Create Bootable USB with Rufus

1. Download and Install Rufus

Visit the Rufus official website.
Download the latest version (portable, no installation required).
Open the program by double-clicking Rufus.exe.

2. Insert Your USB Drive

Plug your USB flash drive into your computer.
Rufus will automatically detect it under Device.

⚠️ Note: All data on the USB will be erased. Backup your important files first.

3. Select Windows 10 ISO File

Under Boot selection, click SELECT.
Browse and choose the Windows 10 ISO file you downloaded.

4. Configure Partition Scheme

Partition scheme:
- Choose MBR if installing on BIOS/Legacy systems.
- Choose GPT if installing on UEFI systems.
File system: Leave as NTFS (default).
Cluster size: Leave as default.

5. Start Creating Bootable USB

Once settings are ready, click START.
Rufus may prompt to download additional files—accept if needed.
A warning will appear that all data on the USB will be destroyed. Click OK to proceed.

6. Wait for Completion

Rufus will format the USB and copy all Windows installation files.
The process may take several minutes depending on USB speed.
When the status bar turns green and says READY, your bootable USB is done.

🚀 How to Use the Bootable USB

Insert the USB drive into the target computer.
Restart the computer and enter the boot menu (usually by pressing F2, F12, ESC, or DEL, depending on manufacturer).
Select your USB drive as the boot device.
Follow the on-screen instructions to install Windows 10.

🎯 Conclusion

Using Rufus makes creating a bootable USB for Windows 10 simple and fast. With just a few steps—selecting your USB, choosing the ISO, and starting the process—you’ll be ready to install or repair Windows 10 on any computer.

🎂 Happy Belated Birthday, Linux! 🐧💻

Siswoyo Siswoyo — Tue, 26 Aug 2025 13:20:30 +0000

On 25 August 1991, a young Finnish computer science student named Linus Torvalds posted a short message on the MINIX newsgroup. In it, he introduced his new project: a free operating system kernel. At the time, he called it “just a hobby, won’t be big and professional like GNU.”

That “hobby” turned into Linux — and the world of technology has never been the same.

🌱 The Beginning

Torvalds’ announcement on 25 August 1991 sparked something special. By releasing his source code and inviting collaboration, he planted the seed for a project that would grow into a global movement. Developers everywhere joined in, contributing ideas, fixes, and improvements.

This open and collaborative model became the DNA of Linux, and it remains its strength to this day.

📜 Key Milestones in Linux History

25 Aug 1991 – Linus Torvalds announces Linux to the world.
1992 – Linux adopts the GNU General Public License (GPL), ensuring it remains free and open-source.
1996 – Tux the Penguin, designed by Larry Ewing, becomes the official Linux mascot.
2000s – Linux becomes the backbone of the internet, powering the majority of servers.
2008 – Android, built on the Linux kernel, begins transforming the mobile industry.
Today – Linux powers 96% of the top 1 million servers, all of the world’s top 500 supercomputers, and is at the heart of cloud platforms, containers, and IoT.

🌍 The Impact of Linux

Linux is more than an operating system — it’s a philosophy and a community.

Freedom – Anyone can study, modify, and share it.
Collaboration – Thousands of contributors worldwide continue to evolve it.
Innovation – From smartphones to space missions, Linux makes the impossible possible.

Without Linux, the internet, mobile computing, AI research, and even cloud platforms would look completely different.

🎉 Celebrating Linux Today

Though we’re a little late to say it:

🎉 Happy Belated Birthday, Linux! 🐧

More than three decades later, Linux remains a symbol of openness, stability, and progress. From students learning their first command line to engineers deploying global infrastructure — Linux belongs to everyone.

Here’s to the next chapter of innovation and community-driven growth. 💻✨

Choosing `UUID` for Unique IDs in a Multi-System Environment

Siswoyo Siswoyo — Sat, 23 Aug 2025 11:42:41 +0000

When designing a database schema, the choice of unique identifier is critical for scalability, data integration, and future-proofing. While databases traditionally use SERIAL (auto-increment integers), in modern distributed and service-oriented architectures, UUID (Universally Unique Identifier) is often the better choice.

Why Not `SERIAL`?

A SERIAL or BIGSERIAL column generates sequential IDs (1, 2, 3...). This works fine for a single, isolated database but creates challenges when scaling:

ID collisions during merges: Two different systems may both have a record with id = 100. Merging them becomes complex.
Predictable IDs: The sequence can reveal the number of records (e.g., knowing you have 50,000 customers).
Sharding and replication issues: Multiple services writing to their own databases may generate overlapping IDs.

Why Use `UUID` Everywhere?

A UUID is a 128-bit identifier that is globally unique. Using UUIDs for both master tables (e.g., customers, products) and transaction tables (e.g., orders, invoices) brings key benefits:

✅ Advantages

Seamless data merging

Whether merging customers or orders across services, IDs will never clash. This simplifies integration projects.
Supports distributed systems

Microservices, event-driven architectures, and multi-database systems can generate IDs independently without coordination.
Future-proofing

Even if today you only have one database, tomorrow you might need to replicate, shard, or consolidate with another system.
Security

UUIDs are non-sequential, making it harder for outsiders to guess the number of records or enumerate IDs.

⚠️ Trade-offs

Larger storage size (16 bytes vs. 4 bytes for integers).
Slightly slower indexing and joins.
Harder to read/debug manually (though often hidden behind APIs).

Example Schema

Master Table: Customers

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

CREATE TABLE customers (
    customer_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL
);

Transaction Table: Orders

CREATE TABLE orders (
    order_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    customer_id UUID NOT NULL REFERENCES customers(customer_id),
    order_date TIMESTAMP DEFAULT now(),
    amount NUMERIC(10,2) NOT NULL
);

Final Decision

If your system might merge data across multiple databases, services, or environments,
then the consistent choice is to use UUID for all primary keys — both master data and transactional data.

This avoids conflicts, simplifies future integrations, and aligns with best practices for distributed systems.

10 DEV.to Features Every Member Should Know

Siswoyo Siswoyo — Tue, 19 Aug 2025 20:16:05 +0000

DEV.to is more than just a blogging platform — it’s a thriving community for developers to share knowledge, learn, and grow. Whether you’re new to DEV or have been around for a while, here are 10 essential features every member should know about:

1. 📝 Write & Publish Articles

The core of DEV is writing. You can share tutorials, case studies, opinions, or personal stories. DEV supports Markdown, making it simple to format your posts with code snippets, images, and embeds.

2. 🏷️ Use Tags Effectively

Tags are powerful for discoverability. When writing, you can add up to 4 tags that describe your article. Popular tags like #javascript, #python, #webdev, and #programming can help reach the right audience.

3. 💬 Engage Through Comments

DEV isn’t just about writing — it’s about conversation. Engage with readers and writers in the comments. Meaningful discussions often add as much value as the article itself.

4. 🔖 Save Posts with Reading List

Found something interesting but no time to read? Hit “Save” and add it to your Reading List. You can access it anytime from your profile to keep track of useful resources.

5. ❤️ Reactions & Unicorns

Besides a standard like (❤️), DEV offers fun reactions like unicorns 🦄 for magical posts and raised hands 🙌 for agreement. These small touches make engagement more expressive.

6. 🌱 Follow Authors & Tags

Build your feed by following your favorite authors and tags. This personalizes your experience so you see content that matches your interests and career growth goals.

7. 📊 Analytics for Writers

When you publish, you can track how your article performs through built-in analytics. View stats like page views, reactions, and comment activity to understand what resonates with readers.

👉 You can access analytics by going to your Dashboard → Posts → “Stats” on any article.

8. 🤝 Connecting with Other Members

DEV encourages open and public interactions. You can connect with others in two simple ways:

Comments → Share your thoughts, ask questions, or start conversations directly under posts.
Profile links → Many members include links to their GitHub, Twitter, portfolio, or email on their profiles if they’re open to external connections.

This approach keeps discussions transparent while still giving you ways to network with developers outside the platform.

9. 🚀 Forem & Open Source Nature

DEV is powered by Forem, an open-source platform. This means the community can contribute improvements, request features, or even spin up their own communities using the same software.

10. 🎯 DEV Challenges

One of the most exciting ways to participate on DEV is through DEV Challenges. These are themed, community-wide prompts where you can share articles, tutorials, or projects around a specific topic.

Here’s why Challenges are worth exploring:

Learn by doing → Each challenge gives you a theme or problem to solve, encouraging you to experiment with new technologies or practices.
Boost your visibility → Challenge submissions often get featured and attract more reactions, comments, and followers than standard posts.
Connect with the community → Since many people contribute, challenges spark discussions and let you see diverse approaches to the same topic.
Gain recognition → Some challenges are sponsored and include special shoutouts, badges, or even small prizes for participants.

👉 You can find active and past challenges directly on DEV’s Challenge page.

✅ Final Thoughts

DEV.to is more than a blogging site — it’s a learning hub, networking space, and open-source project. By using these 10 features, you’ll get the most out of your experience, whether you’re here to learn, share, or connect.

Implementing SSL with acme.sh on Ubuntu

Siswoyo Siswoyo — Mon, 18 Aug 2025 11:34:10 +0000

This guide explains how to install and configure acme.sh for SSL certificate management using Let's Encrypt, integrate it with Nginx, set up automatic renewal with cron, and perform manual renewal if needed.

1️⃣ Install acme.sh

acme.sh is a pure shell script for managing SSL certificates.

curl https://get.acme.sh | sh

Add it to your shell environment:

source ~/.bashrc

Verify installation:

acme.sh --version

2️⃣ Issue an SSL Certificate
Using Webroot Mode (Recommended for Nginx)
Replace yourdomain.com with your actual domain:

acme.sh --issue -d yourdomain.com -d www.yourdomain.com -w /var/www/html

Certificates are stored in:

~/.acme.sh/yourdomain.com/

3️⃣ Install the Certificate to Nginx

sudo mkdir -p /etc/nginx/ssl/yourdomain.com
acme.sh --install-cert -d yourdomain.com \
--key-file       /etc/nginx/ssl/yourdomain.com/key.pem \
--fullchain-file /etc/nginx/ssl/yourdomain.com/fullchain.pem \
--reloadcmd     "systemctl reload nginx"

4️⃣ Configure Nginx to Use SSL
Edit your Nginx config file (e.g., /etc/nginx/sites-available/yourdomain.conf):

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    # Redirect HTTP to HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name yourdomain.com www.yourdomain.com;

    ssl_certificate     /etc/nginx/ssl/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/yourdomain.com/key.pem;

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

Test and reload Nginx:

sudo nginx -t
sudo systemctl reload nginx

5️⃣ Set Up Auto-Renewal with crontab
acme.sh usually sets this up automatically. Check:

crontab -l

Expected output:

0 0 * * * "~/.acme.sh"/acme.sh --cron --home "~/.acme.sh" > /dev/null

If not present, add manually:

crontab -e

Insert:

0 0 * * * ~/.acme.sh/acme.sh --cron --home ~/.acme.sh > /dev/null

6️⃣ Manually Renew Certificates
Renew a Single Domain
Force renewal before expiration:

acme.sh --renew -d yourdomain.com --force

Reload Nginx:

sudo systemctl reload nginx

Renew All Certificates
To renew all certificates managed by acme.sh at once:

acme.sh --renew-all --force

Reload Nginx after renewal:

sudo systemctl reload nginx

7️⃣ Useful Commands

List all issued certificates:

acme.sh --list

Revoke a certificate:

acme.sh --revoke -d yourdomain.com

Remove a certificate from acme.sh:

acme.sh --remove -d yourdomain.com

8️⃣ Troubleshooting

Open required ports:

sudo ufw allow 80
sudo ufw allow 443

Check Nginx logs:

sudo tail -f /var/log/nginx/error.log

Verify DNS points to your server.

✅ With this setup, SSL will be automatically renewed via cron, integrated with Nginx, and can be manually renewed anytime — either for one domain or all at once.

Best Practices for Creating Error Code Patterns

Siswoyo Siswoyo — Fri, 08 Aug 2025 13:13:58 +0000

Error codes play a crucial role in helping developers, users, and systems understand what went wrong in an application. A well-structured error code pattern improves clarity, debugging, maintainability, and support.

🎯 Why Use a Standard Error Code Pattern?

🔍 Easier Debugging: Quickly identify the origin and nature of an error.
📈 Better Monitoring & Alerts: Group and analyze issues across services.
🤝 Improved Developer Experience: Easier to document, troubleshoot, and integrate.
📚 Structured Documentation: Helps technical writers and QA teams.

🧱 Structure of an Error Code

A best practice for error code formatting follows a modular pattern, for example:

Example: ORD-API-001

Component	Description
`ORD`	Domain/Service Code (e.g., Order Service)
`API`	Error Category (e.g., API validation, authentication)
`001`	Sequential or categorized numeric code for easy identification

🔖 Recommended Naming Convention

Part	Format	Example	Description
Domain	3 uppercase letters	`ORD`, `USR`, `DLV`, `PRD`	Related to the business domain or microservice
Category	2–4 uppercase letters	`API`, `USC`, `DLV`, `GRPC`, `DB`	Classifies type of error
Code	3 digits	`001` to `999`	Incremental or logical grouping

🗂️ Suggested Error Categories

Category Code	Category Name	Description
`API`	API Errors	Errors related to HTTP requests (validation, auth, etc.)
`USC`	User Service Errors	Specific to user profile, login, registration, etc.
`DLV`	Delivery/Validation	Errors in delivery services, logistics validation, etc.
`GRPC`	gRPC Communication	Errors related to gRPC service-to-service communication
`DB`	Database Errors	Database read/write, connection, schema validation
`INT`	Integration Errors	External API failures, payment gateway, 3rd-party service issues
`SYS`	System Errors	Unexpected exceptions, resource limits, timeout

🧾 Full Error Code Examples

Error Code	Message	Description
`ORD-API-001`	Invalid order payload	The request body failed schema validation
`ORD-GRPC-002`	Failed to fetch pricing from PRD	gRPC call to pricing service failed
`USR-USC-003`	User email already exists	Business logic validation for duplicate users

🧩 Optional Enhancements

1. Localization Support

{
  "error_code": "USR-USC-003",
  "message": "User email already exists",
  "message_i18n": {
    "id": "Email sudah digunakan",
    "fr": "L'e-mail existe déjà"
  }
}

2. Standard Error Response Format

{
  "success": false,
  "error_code": "ORD-API-001",
  "message": "Invalid order payload",
  "details": {
    "field": "quantity",
    "issue": "Must be greater than 0"
  },
  "timestamp": "2025-08-07T17:00:00Z"
}

🧪 Tips for Designing and Maintaining Error Codes

Tip	Description
✅ Prefix with domain/service name	Keep things traceable across microservices
✅ Centralize error definitions	Use a shared config file or database
✅ Avoid magic numbers	Use enums or constants in code
✅ Version your error codes	Allow backward compatibility
✅ Group related codes	Group 100–199 for validation, 200–299 for business logic, etc.
❌ Don’t expose internal exceptions	Convert to user-friendly messages and codes
❌ Don’t reuse error codes	Ensure one code maps to one error type only

📚 Summary
A well-designed error code pattern helps your application scale, improves DX (developer experience), and reduces debugging time. Always keep error codes:

Predictable
Descriptive
Consistent
Extensible