DEV Community: TEN

Why Writing Still Matters — A Developer's Case for Thinking Out Loud

TEN — Fri, 13 Mar 2026 08:35:10 +0000

It Starts with Curiosity

I'm the kind of person who makes a plan whenever something sparks my curiosity.

Whether it's hunting down a new restaurant or exploring a neighborhood I've never been to — I'm drawn to discovering new things. I usually start by looking for places with high ratings and strong reviews. When I find a gem, I post it on Instagram and revisit it whenever the craving hits.

That same curiosity carries over into my work. When a new technology comes out, I check it out — especially if it's from a reputable institution or already being adopted by the industry. If it seems useful, I work it into my workflow and document the entire process.

Curiosity is in my nature, but I also don't want to forget what worked. Writing is how I hold on to what I learn.

Platform Migration: From Tistory to GitHub

For about four years, I used a Korean blogging platform called Tistory. As a developer, it eventually started to feel inefficient for writing. That's when I started looking for alternatives.

During the search, I realized a critical problem: I'd been building all my content entirely within the platform's ecosystem. Years of writing, locked into a single platform.

I realized I needed a fundamentally different approach. And here's the solution I came up with:

GitHub — Version control and content ownership
Notion — Image hosting (linked as external URLs)
Platform-specific tokens — For deploying to publishing sites

This setup gave me the portability and control I was missing.

Trying Other Platforms

During the transition, I experimented with a few options:

Blogger — Felt clunky and outdated
Medium — Poor markdown support, and the API token system was essentially deprecated

After weighing the trade-offs, keeping my content on GitHub and deploying to dev.to made the most sense.

Platform dependency creates unnecessary friction, and I'd rather own my content than rent space for it.

Why I Write

In a world where AI can answer nearly any question instantly, why bother writing at all?

Because writing forces me to think. I could rely on AI for quick answers — and I do, regularly. AI is remarkably powerful, and it's only going to get better.

But I've realized that without the deliberate process of organizing my thoughts and putting them into words, far less of what I learn actually sticks.

Writing isn't just about producing content. It's a form of active learning. When I write about a concept, I'm forced to confront what I truly understand versus what I merely skimmed over. The gaps become obvious.

The act of explaining something — even to an imaginary reader — deepens my comprehension in a way that passively consuming information never could.

So I write to remember. I write to understand. And I write to build something that compounds over time.

Why English?

The answer is straightforward, but the reasoning goes deeper than it might seem.

I work as a developer, and at times, as a project-oriented problem solver. As AI capabilities continue to advance, I believe human-to-human communication will become not less important, but more so.

Here's why. As AI improves, the cost and effort of implementation continue to drop. Development itself is getting faster, and learning curves are shortening thanks to both personal growth and AI assistance. In my own experience, I spend far less time debugging or digging through official documentation than I used to.

But a different kind of work is becoming more prominent: deciding what to build and why — through discussion, negotiation, and alignment between people. These conversations happen in natural language, not in code. They require nuance, cultural awareness, and the ability to articulate ideas clearly.

Of course, engineers who deeply understand a project's technical constraints will always be essential. But there is already no shortage of capable developers — and their number will only continue to grow.

What distinguishes one developer from another is increasingly about communication, judgment, and the ability to bridge gaps between teams, stakeholders, and cultures.

At its core, my role is to translate someone's intent and vision into working software. To do that well, I want as little friction as possible between myself and the people whose ideas I'm helping bring to life.

No matter how advanced AI becomes, we still work with people.

That's why, although I'm Korean and currently living and working in Japan, I make a deliberate effort to write and communicate in English. It's about expanding my reach and reducing barriers. English is the lingua franca of the tech world, and investing in it is a long-term strategic decision.

The Long Game

The tech industry will continue evolving at a relentless pace. Frameworks will rise and fall. Tools will come and go. But the ability to learn, to communicate clearly, and to think critically — those are durable skills.

What truly matters is building the habit of persistence.

Keep learning. Keep writing. Keep pushing into unfamiliar territory.

Some days motivation runs low. That's normal. I've found that even watching a good talk or a motivational video can reignite the spark. The key isn't to feel inspired every single day — it's to show up consistently, even when you don't.

Writing is how I show up. And that's why it still matters.

CI/CD with Jenkins, Docker & Git - A Simple Guide for Junior Developers

TEN — Wed, 21 Jan 2026 02:55:38 +0000

Easy CI/CD Setup with Jenkins, Docker & Git

What You'll Need

Before we start, make sure you have:

Basic GitHub knowledge
A Linux server (or VM)
Some Docker experience

Overview

Hey! If you're a junior developer looking to learn CI/CD, you're in the right place! This guide is specifically written for beginners who want to understand how to automate their deployment process.

Today I'm going to walk you through setting up CI/CD with Docker and Jenkins from scratch. Don't worry if this sounds intimidating - it's actually pretty straightforward! With modern tools (and a bit of AI help), anyone can build a solid pipeline without too much hassle.

So, without further ado, let's dive in!

Step 1: GitHub Setup

First things first - let's get your GitHub ready:

Create a repository on GitHub for your project
Go to Settings → Developer settings → Personal access tokens
Generate a new token (make sure to save it somewhere safe - you'll need it later!)

Step 2: Local Development

Now let's work on your local machine:

Write your code - use whatever language you prefer (Java, Python, Go, Node.js - anything works!)
Create a Dockerfile for building your app
Test the Docker build locally to make sure everything works:

   docker build -t your-app:latest .

If it builds successfully, you're good to go!

Step 3: Server Setup

Time to prep your deployment server:

Update your package manager:

   sudo apt update -y

Install Docker and docker-compose:

   sudo apt install docker.io docker-compose-plugin -y

Create a docker-compose file for Jenkins:

Here's a simple setup that works:

   services:
     jenkins:
       image: jenkins/jenkins:lts
       user: root  # avoid permission errors
       ports:
         - "8080:8080"
       volumes:
         - ./jenkins_home:/var/jenkins_home
         - /var/run/docker.sock:/var/run/docker.sock

Important tips:

The volumes setup ensures your Jenkins config persists across restarts
Mounting the Docker socket lets Jenkins control Docker on the host

- Pro tip: Store this compose file in a GitHub repo for version control!

Step 4: Jenkins Configuration

Alright, now for the fun part - setting up Jenkins:

Add GitHub credentials:
- Use that personal access token you created earlier
- Store it securely in Jenkins credentials manager
Create a Pipeline with these stages:

Your pipeline should look something like this (don't worry, you can use AI to help write the Jenkinsfile!):

Checkout - Pull your code from GitHub
Build - Build your Docker image
Login - Authenticate with Docker Hub
Push - Push your image to Docker Hub
SSH to server - Connect to your deployment server
Deploy - Run your updated container
1. Set up automatic triggering:

You have two options here:

Option A: Webhooks (if you have a public IP)

Simply create a webhook in your GitHub repository settings
Jenkins will automatically trigger the build as soon as you push code
This is the cleanest approach!

Option B: Poll SCM (if you don't have a public IP)

Set up a Jenkins cron schedule to check for updates (e.g., every 2 minutes)
Make sure you have a Jenkinsfile in your repository
Not as instant as webhooks, but gets the job done

Bonus: Easy Log Viewing with Dozzle

Want to see your container logs easily? Let me introduce you to Dozzle - it's a game changer!

Go to the Dozzle homepage
Copy the docker installation command
Run it on your Linux server:

   docker run -d --name dozzle -v /var/run/docker.sock:/var/run/docker.sock -p 9999:9999 amir20/dozzle:latest

That's it! Now you can view all your container logs in a nice web interface at http://your-server:9999 🎉

No more SSH-ing into your server just to check logs!

Wrapping Up

Congrats! You now have a fully working CI/CD pipeline. Every time you push code to GitHub, Jenkins will automatically build and deploy your app. Pretty cool, right?

The best part? Once it's set up, you can pretty much forget about it and focus on writing code. Your deployments will just... happen.

Happy coding! 🚀

MySQL Performance Optimization

TEN — Wed, 28 May 2025 06:59:41 +0000

Complete Guide to MySQL Performance Optimization

MySQL is one of the most popular relational databases, but it can experience performance issues in large-scale applications or high-traffic environments. This document provides strategies and techniques for optimizing MySQL database performance.

Scalability
Performance Optimization
Data Consistency & High Availability
Query Optimization
Hardware & System Configuration
Partitioning
Advanced Optimization Techniques
Case Studies
New Features in MySQL 8.0+
Key Performance Monitoring Metrics

1. Scalability

Vertical Scaling

Upgrade to a server with more powerful CPU, memory, and storage
Pros: Easy to implement
Cons: Limited scalability and exponentially increasing costs

Read Replica Configuration

Steps to distribute read traffic across multiple replicas:

Prepare two servers
Modify or add the following values in /etc/mysql/my.cnf:

server-id = 1        # Must be unique across servers
log_bin = mysql-bin  # Required log for replication
binlog_format = ROW  # ROW format is generally recommended

Create a user and grant privileges required for replication, then apply the privileges:

CREATE USER 'replication_user'@'%' IDENTIFIED BY 'password';
GRANT REPLICATION SLAVE ON *.* TO 'replication_user'@'%';
FLUSH PRIVILEGES;

Check the current status of the master:

SHOW MASTER STATUS;

If there are no issues, dump the existing master data and import it to the replica:

mysqldump -u root -p --all-databases --master-data=2 --single-transaction > dump.sql
mysql -u root -p < dump.sql

Set the server-id on the replica to be different from the master.
Configure the slave's database to connect to the master and start the slave:

CHANGE MASTER TO
  MASTER_HOST='master_host_ip',         -- Set IP or domain of the Master server
  MASTER_USER='replication_user',       -- Replication-specific user created on the Master
  MASTER_PASSWORD='password',           -- Password for the replication user
  MASTER_LOG_FILE='mysql-bin.000001',   -- Current Binlog filename from SHOW MASTER STATUS
  MASTER_LOG_POS=107;                   -- Replication start position in Binlog (byte offset) from SHOW MASTER STATUS

START SLAVE;  -- or START REPLICA; (depending on MySQL version)

ProxySQL for Read/Write Separation

ProxySQL can be implemented on a separate server from the master and slave to handle read/write separation and load balancing:

# ProxySQL configuration example
UPDATE mysql_servers SET weight=10 WHERE hostname='reader1';
UPDATE mysql_servers SET weight=5 WHERE hostname='reader2';
LOAD MYSQL SERVERS TO RUNTIME;

Although this approach requires more resources, it can be used for the following reasons:

Benefits of using ProxySQL:

Simplified application architecture:
Applications can be unaware of read/write separation or replica server management,
as business logic only needs to connect to ProxySQL.
Advanced load balancing capabilities:
Efficiently distributes load when working with 3+ replicas using weight-based algorithms.
Example: 50% of traffic to one replica, 30% to another, and 20% to a third.
Real-time traffic management:
Operations teams can add/remove servers or adjust weights without application modifications,
by changing only ProxySQL settings.
Enhanced failure handling and high availability:
When combined with Orchestrator, ProxySQL enables automatic failure detection and failover.

Sharding

MySQL doesn't natively support sharding, so filtering must be implemented at the application or middleware level based on specific values.
Systems without built-in sharding support may need to carefully evaluate if the complexity of implementing sharding outweighs the benefits.

Sharding approaches:

Data distribution: Spread data across multiple servers (horizontal partitioning)
Implementation methods:
- Range-Based Sharding
- Hash-Based Sharding
- Directory-Based Sharding

Example implementation:

-- Example table for Shard 1 (User IDs 1-1000000)
CREATE TABLE users_shard1 (
  id INT PRIMARY KEY,
  name VARCHAR(100),
  /* Other fields */
  CONSTRAINT check_id CHECK (id BETWEEN 1 AND 1000000)
);

-- Example table for Shard 2 (User IDs 1000001-2000000)
CREATE TABLE users_shard2 (
  id INT PRIMARY KEY,
  name VARCHAR(100),
  /* Other fields */
  CONSTRAINT check_id CHECK (id BETWEEN 1000001 AND 2000000)
);

2. Performance Optimization

Problem: Query performance degradation when processing large amounts of data or high traffic.

Solutions:

Index Optimization

Best practices for indexing:

Design appropriate indexes: Create indexes for columns frequently used in WHERE, JOIN, and ORDER BY clauses

  -- Create a basic index
  CREATE INDEX idx_last_name ON users(last_name);

  -- Create a composite index
  CREATE INDEX idx_last_first_name ON users(last_name, first_name);

  -- Check index status
  SHOW INDEX FROM users;

Remove excessive indexes: Unnecessary indexes can degrade write performance

  -- Check unused indexes
  SELECT * FROM sys.schema_unused_indexes;

  -- Drop an index
  DROP INDEX idx_unused ON table_name;

Slow Query Optimization

Identifying and addressing slow queries:

Enable and analyze Slow Query Log

  -- Enable Slow Query Log
  SET GLOBAL slow_query_log = 'ON';
  SET GLOBAL long_query_time = 1; -- Log queries taking longer than 1 second
  SET GLOBAL slow_query_log_file = '/var/log/mysql/mysql-slow.log';

  -- Use analysis tools (e.g., pt-query-digest)
  pt-query-digest /var/log/mysql/mysql-slow.log

Connection Pooling

Optimizing database connection management:

Benefits: Reduces overhead of connection creation/destruction
Implementation options:
- Java: HikariCP, C3P0
- Node.js: mysql2/promise-pool
- PHP: PDO persistent connections

Example implementation:

// Example of connection pooling in Node.js
const mysql = require("mysql2/promise");
const pool = mysql.createPool({
  host: "localhost",
  user: "user",
  password: "password",
  database: "db_name",
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0,
});

3. Data Consistency & High Availability

Problem: Risk of service interruption due to failures or data loss.

Solutions:

Replication

Master-Slave Structure: Write to master, read from slaves

  -- Master configuration (my.cnf)
  server-id = 1
  log_bin = mysql-bin
  binlog_format = ROW

  -- Slave configuration (my.cnf)
  server-id = 2
  relay_log = mysql-relay-bin
  read_only = ON

Group Replication: Multiple nodes operating as a group, automatic failure detection

  -- Group Replication setup
  INSTALL PLUGIN group_replication SONAME 'group_replication.so';
  SET GLOBAL group_replication_bootstrap_group = ON;
  START GROUP_REPLICATION;

Automatic Failover

High availability solutions:

Orchestrator: Modern, widely-used solution with GitHub Certification

Example configuration:

# MHA Manager configuration file example (app1.cnf)
[server default]
user=mha
password=password
ssh_user=root
repl_user=repl
repl_password=slavepass

[server1]
hostname=master.example.com

[server2]
hostname=slave1.example.com

Backup and Recovery Strategy

Logical Backup: SQL dumps using mysqldump

  # Full database backup
  mysqldump -u root -p --all-databases > full_backup.sql

  # Backup specific database
  mysqldump -u root -p my_database > my_database_backup.sql

Physical Backup: Incremental backups using XtraBackup

  # Full backup
  xtrabackup --backup --target-dir=/backup/full

  # Incremental backup
  xtrabackup --backup --target-dir=/backup/inc1 --incremental-basedir=/backup/full

4. Query Optimization

Using EXPLAIN Command

Analyze query execution plans to identify bottlenecks

  EXPLAIN SELECT * FROM users
  JOIN orders ON users.id = orders.user_id
  WHERE users.status = 'active';

Query Rewriting

Eliminate unnecessary JOINs: Use subqueries or temporary tables
Optimize WHERE conditions: Modify condition expressions to utilize indexes
Use LIMIT: Restrict result set size

  -- Before optimization
  SELECT * FROM large_table;

  -- After optimization
  SELECT * FROM large_table LIMIT 100;

Pagination Optimization

Use keyset-based pagination instead of offset-based

  -- Inefficient offset method
  SELECT * FROM products ORDER BY id LIMIT 10 OFFSET 1000000;

  -- Efficient keyset method
  SELECT * FROM products WHERE id > 1000000 ORDER BY id LIMIT 10;

5. Hardware & System Configuration

Server Resource Optimization

Memory allocation: Set innodb_buffer_pool_size to 70-80% of total memory

  -- For a 32GB memory server
  SET GLOBAL innodb_buffer_pool_size = 25769803776; -- 24GB

I/O optimization: Use SSDs, RAID configuration
CPU utilization: Ensure sufficient modern processor cores

MySQL Configuration Optimization

Tune my.cnf file

  # InnoDB settings
  innodb_buffer_pool_size = 24G
  innodb_log_file_size = 1G
  innodb_flush_log_at_trx_commit = 2

  # Query cache
  query_cache_type = 0  # Deprecated in MySQL 8.0+

  # Connection settings
  max_connections = 500
  thread_cache_size = 32

OS Level Optimization

File system: ext4, XFS
I/O scheduler: deadline, noop
Network tuning: TCP settings optimization

6. Partitioning

Table Partitioning

Divide large tables into smaller units for management

  -- Date-based partitioning example
  CREATE TABLE sales (
    id INT NOT NULL,
    sale_date DATE NOT NULL,
    amount DECIMAL(10,2),
    PRIMARY KEY (id, sale_date)
  )
  PARTITION BY RANGE (YEAR(sale_date)) (
    PARTITION p2021 VALUES LESS THAN (2022),
    PARTITION p2022 VALUES LESS THAN (2023),
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION future VALUES LESS THAN MAXVALUE
  );

Partition Management

Add, delete, and reorganize partitions

  -- Add partition
  ALTER TABLE sales ADD PARTITION (PARTITION p2024 VALUES LESS THAN (2025));

  -- Delete partition
  ALTER TABLE sales DROP PARTITION p2021;

  -- Reorganize partition
  ALTER TABLE sales REORGANIZE PARTITION future INTO (
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION future VALUES LESS THAN MAXVALUE
  );

7. Advanced Optimization Techniques

Data Caching Strategies

Query Result Caching with Redis

Cache frequently accessed data or computationally expensive query results

// Example of query result caching with Redis in PHP
function getProductDetails($productId) {
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);

    $cacheKey = "product:$productId";
    $cachedResult = $redis->get($cacheKey);

    if ($cachedResult) {
        return json_decode($cachedResult, true);
    }

    // Query DB if not in cache
    $db = new PDO('mysql:host=localhost;dbname=store', 'user', 'password');
    $stmt = $db->prepare("SELECT * FROM products WHERE id = ?");
    $stmt->execute([$productId]);
    $result = $stmt->fetch(PDO::FETCH_ASSOC);

    // Store in cache (valid for 30 minutes)
    $redis->setex($cacheKey, 1800, json_encode($result));

    return $result;
}

Using Memory Tables

Store frequently accessed data in memory tables to eliminate I/O bottlenecks

-- Create a memory table
CREATE TABLE cache_table (
  id INT NOT NULL,
  data VARCHAR(255) NOT NULL,
  PRIMARY KEY (id)
) ENGINE=MEMORY;

-- Insert data
INSERT INTO cache_table
SELECT id, data FROM frequent_access_data;

Large Data Processing Optimization

Batch Processing

Process large volumes of records in batches rather than all at once

-- Batch deletion example (10,000 records at a time)
SET @batch_size = 10000;
SET @total = (SELECT COUNT(*) FROM old_logs WHERE created_at < '2023-01-01');
SET @processed = 0;

WHILE @processed < @total DO
  DELETE FROM old_logs
  WHERE created_at < '2023-01-01'
  LIMIT @batch_size;

  SET @processed = @processed + ROW_COUNT();
  SELECT SLEEP(0.5); -- Short pause to prevent server overload
END WHILE;

Using Temporary Tables

Utilize temporary tables for complex queries or large data processing

-- Create and index a temporary table
CREATE TEMPORARY TABLE temp_results (
  user_id INT,
  total_orders INT,
  total_amount DECIMAL(10,2),
  INDEX (user_id)
);

-- Store intermediate results
INSERT INTO temp_results
SELECT user_id, COUNT(*), SUM(amount)
FROM orders
WHERE created_at > DATE_SUB(NOW(), INTERVAL 1 MONTH)
GROUP BY user_id;

-- Use temporary table in final query
SELECT u.name, t.total_orders, t.total_amount
FROM users u
JOIN temp_results t ON u.id = t.user_id
WHERE t.total_amount > 1000;

Transaction Optimization

Limiting Transaction Size

Large transactions increase memory usage and lock contention

-- Wrong approach: One large transaction
START TRANSACTION;
-- Process millions of records
COMMIT;

-- Improved approach: Split into smaller transactions
SET @offset = 0;
SET @limit = 10000;
SET @total = (SELECT COUNT(*) FROM source_table);

WHILE @offset < @total DO
  START TRANSACTION;

  -- Process in batches
  INSERT INTO target_table
  SELECT * FROM source_table LIMIT @offset, @limit;

  COMMIT;
  SET @offset = @offset + @limit;
END WHILE;

Setting Isolation Levels

Choose the optimal transaction isolation level for your requirements

-- Check transaction isolation level
SELECT @@transaction_isolation;

-- For read performance priority
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

-- For data consistency priority
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

MySQL Optimization in Cloud Environments

AWS RDS Optimization

Parameter Group settings

# AWS RDS Parameter Group optimization settings
innodb_buffer_pool_size = {DBInstanceClassMemory*0.75}
max_connections = {DBInstanceClassMemory/12582880}
innodb_read_io_threads = 16
innodb_write_io_threads = 16

Using Aurora MySQL
- Distributed storage system for optimized data I/O
- Fast replication and failure recovery
- Serverless option for automatic scaling

Monitoring and Performance Analysis

Utilize AWS CloudWatch and Performance Insights

# AWS CLI command for DB monitoring
aws cloudwatch get-metric-statistics \
  --namespace AWS/RDS \
  --metric-name CPUUtilization \
  --start-time 2023-05-01T00:00:00Z \
  --end-time 2023-05-01T23:59:59Z \
  --period 3600 \
  --statistics Average \
  --dimensions Name=DBInstanceIdentifier,Value=my-db-instance

Data Compression and Archiving

Table Compression

Save disk space and improve I/O performance

-- InnoDB table compression
CREATE TABLE compressed_table (
  id INT NOT NULL AUTO_INCREMENT,
  data LONGTEXT,
  PRIMARY KEY (id)
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=8;

Cold Data Archiving

Move old data to separate storage

-- Create archive table
CREATE TABLE orders_archive LIKE orders;

-- Move old data
INSERT INTO orders_archive
SELECT * FROM orders
WHERE order_date < DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR);

-- Delete moved data from source
DELETE FROM orders
WHERE order_date < DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR);

8. Case Studies

Large Log Table Optimization

Problem: Performance degradation in a table accumulating millions of logs daily

Solution Strategy:

Apply partitioning (daily/monthly data separation)
Add indexes for log types
Automate cold data archiving

Implementation Code:

-- Create partitioned log table
CREATE TABLE application_logs (
  id BIGINT NOT NULL AUTO_INCREMENT,
  log_timestamp DATETIME NOT NULL,
  log_level ENUM('ERROR', 'WARN', 'INFO', 'DEBUG') NOT NULL,
  service VARCHAR(50) NOT NULL,
  message TEXT,
  PRIMARY KEY (id, log_timestamp)
) PARTITION BY RANGE (TO_DAYS(log_timestamp)) (
  PARTITION p_current VALUES LESS THAN (TO_DAYS(CURRENT_DATE + INTERVAL 1 DAY)),
  PARTITION p_future VALUES LESS THAN MAXVALUE
);

-- Stored procedure for adding monthly partitions
DELIMITER //
CREATE PROCEDURE add_month_partition()
BEGIN
  DECLARE next_month_start DATE;
  DECLARE partition_name VARCHAR(50);

  -- Calculate first day of next month
  SET next_month_start = DATE_ADD(DATE_FORMAT(CURRENT_DATE, '%Y-%m-01'), INTERVAL 1 MONTH);
  SET partition_name = CONCAT('p_', DATE_FORMAT(next_month_start, '%Y_%m'));

  -- Reorganize the last partition
  SET @sql = CONCAT(
    'ALTER TABLE application_logs REORGANIZE PARTITION p_future INTO (',
    'PARTITION ', partition_name, ' VALUES LESS THAN (TO_DAYS(''', next_month_start, ''')),',
    'PARTITION p_future VALUES LESS THAN MAXVALUE)'
  );

  PREPARE stmt FROM @sql;
  EXECUTE stmt;
  DEALLOCATE PREPARE stmt;
END //
DELIMITER ;

-- Event scheduler for automatic partition management
CREATE EVENT add_month_partition_event
ON SCHEDULE EVERY 1 MONTH
STARTS DATE_FORMAT(CURRENT_DATE, '%Y-%m-25')
DO CALL add_month_partition();

High-Traffic E-commerce Platform Optimization

Problem: Service disruption due to order surge during sales periods

Solution Strategy:

Read/write separation (operating 5 Read Replicas)
Hot data caching with Redis
Implement a queueing system for write operations

Results:

Response time improved by 85% (850ms → 120ms)
Order processing capacity increased 10x
Service stability achieved 99.99%

9. New Features in MySQL 8.0+

Window Functions

Improve analytical query performance

-- Optimized rank calculation
SELECT
  product_id,
  category_id,
  price,
  RANK() OVER (PARTITION BY category_id ORDER BY price DESC) as price_rank
FROM products;

Common Table Expressions (CTE)

Improve readability and performance of complex queries

-- Recursive CTE for hierarchy traversal
WITH RECURSIVE category_tree AS (
  -- Base case: top-level categories
  SELECT id, name, parent_id, 0 AS depth
  FROM categories
  WHERE parent_id IS NULL

  UNION ALL

  -- Recursive case: child categories
  SELECT c.id, c.name, c.parent_id, ct.depth + 1
  FROM categories c
  JOIN category_tree ct ON c.parent_id = ct.id
)
SELECT * FROM category_tree
ORDER BY depth, name;

Histogram Statistics

Enable more accurate execution plans by the query planner

-- Create histogram
ANALYZE TABLE orders UPDATE HISTOGRAM ON order_status WITH 10 BUCKETS;

-- Check histograms
SELECT * FROM information_schema.column_statistics
WHERE table_name = 'orders' AND column_name = 'order_status';

10. Key Performance Monitoring Metrics

Essential Monitoring Metrics

Query Response Time: Monitor 95th, 99th percentiles
InnoDB Buffer Pool Hit Rate: Aim to maintain above 99%
Connections: Keep below 70% of maximum connections
Disk I/O: IOPS, latency, throughput
Temporary Table Usage: Minimize disk-based temporary tables

Monitoring Tools

MySQL Enterprise Monitor
Prometheus + Grafana
Percona Monitoring and Management (PMM)
SolarWinds Database Performance Analyzer

-- Query to check resource usage
SELECT * FROM performance_schema.memory_summary_global_by_event_name
WHERE event_name LIKE 'memory/innodb/%'
ORDER BY current_alloc DESC LIMIT 10;

-- Check slow queries
SELECT * FROM performance_schema.events_statements_summary_by_digest
ORDER BY sum_timer_wait DESC LIMIT 10;

Conclusion

MySQL database optimization requires a comprehensive approach that considers architecture design, infrastructure configuration, and operational management beyond simple query tuning. Optimization is not a one-time task but a continuous process requiring ongoing monitoring and improvement.

Based on the various strategies and techniques presented in this guide, design and implement optimization measures tailored to the characteristics of your applications and business needs. Improved database performance leads to better service responsiveness, user experience, and ultimately, business outcomes.

References

Effective Troubleshooting - A Comprehensive Guide

TEN — Wed, 28 May 2025 06:48:38 +0000

Troubleshooting Guide for Developers

Overview: A Systematic Approach to Problem Solving

Troubleshooting is the systematic process of identifying, analyzing, and resolving issues in systems, applications, networks, and infrastructure. Rather than merely addressing symptoms, it involves diagnosing root causes and implementing measures to prevent recurrence.

For developers and system operators, troubleshooting is an essential skill. This guide covers fundamental principles, real-world examples, and effective tool usage strategies.

Basic Troubleshooting Flow

The troubleshooting process typically follows these steps (most issues become simpler once you can reproduce them):

1. Problem Identification

Recognize that a problem exists and clearly identify the symptoms.

Examples: "The server is down," "API returns 500 errors," "Database performance has degraded"

2. Problem Reproduction

Attempt to reproduce the issue in a controlled environment to establish consistent conditions for analysis.

3. Root Cause Analysis

Analyze logs, metrics, code, and other relevant data points to identify the underlying cause.

4. Hypothesis Formation & Verification

Develop hypotheses about potential causes and test them systematically.

5. Solution Implementation

Apply the fix by modifying code, changing configuration, or performing necessary system adjustments.

6. Documentation & Retrospective

Document the resolution process and establish preventive measures for similar issues.

Essential Troubleshooting Tools

Several tools can significantly enhance your troubleshooting efficiency:

tail -f - Real-time log monitoring
grep - Pattern searching in logs
top, htop - System resource monitoring
netstat - Network connection status
docker logs - Container log inspection
APM (Application Performance Monitoring) - App performance insights
strace/dtrace - System call tracing
jstack - Java thread dump analysis

Real-world Troubleshooting Examples

Let's examine common troubleshooting scenarios and their solutions from professional environments.

Case 1: Web Server Issues (504 Gateway Timeout)

Symptom: Client API calls resulting in 504 Gateway Timeout errors

Process:

Log analysis across the stack (nginx → backend)

   # Nginx log inspection
   grep "504" /var/log/nginx/error.log | tail -n 100

   # Backend log inspection
   grep "Timeout" /var/log/application/app.log

Database connection delay logs discovered

   WARN  [HikariPool-1] - Connection is not available, request timed out after 30001ms
   ERROR [TransactionManager] - Transaction could not be completed, database connection error

Database connection pool shortage confirmed

   -- Active connection query
   SELECT count(*) FROM information_schema.processlist
   WHERE command != 'Sleep' AND user = 'app_user';

Connection pool settings increased & query optimization implemented

   # application.yml changes
   datasource:
     hikari:
       maximum-pool-size: 20 # Increased from 10
       connection-timeout: 30000
       idle-timeout: 600000

   // Query optimization for N+1 problem
   // Before
   List<Order> orders = orderRepository.findAll();
   for (Order order : orders) {
     order.getItems().size();  // Separate query for each order (N+1)
   }

   // After
   List<Order> orders = orderRepository.findAllWithItems();  // Using JOIN FETCH

Case 2: Post-deployment 500 Errors

Symptom: 500 errors occurring on specific APIs after new deployment

Process:

Code diff analysis between versions

   git diff HEAD~1 HEAD -- src/main/java/com/example/service/UserService.java

NPE (Null Pointer Exception) identified in stack trace

   java.lang.NullPointerException
     at com.example.service.UserService.processUserPreferences(UserService.java:125)
     at com.example.controller.UserController.updatePreferences(UserController.java:57)

Missing parameter handling causing NPE

   // Problematic code
   void processUserPreferences(UserPreferences preferences) {
     String theme = preferences.getTheme().toLowerCase();  // NPE when getTheme() is null
     // ...
   }

Default value handling added and redeployed

   // Fixed code
   void processUserPreferences(UserPreferences preferences) {
     String theme = (preferences.getTheme() != null)
       ? preferences.getTheme().toLowerCase()
       : DEFAULT_THEME;
     // ...
   }

Case 3: Memory Leaks Causing Periodic Server Crashes

Symptom: Java application experiencing OOM (Out of Memory) errors every ~5 days

Process:

Heap dump analysis

   jmap -dump:format=b,file=heap_dump.bin $(pgrep java)

Memory pattern analysis with Eclipse MAT

Identified continuously growing cache objects

Discovered unbounded cache implementation

   // Problematic code
   static final Map<String, DataObject> dataCache = new HashMap<>();

   void processData(String key, DataObject data) {
     dataCache.put(key, data);  // Unlimited cache growth
     // ...
   }

Solution: LRU cache with expiration policy

   // Improved code
   LoadingCache<String, DataObject> dataCache = CacheBuilder.newBuilder()
       .maximumSize(10000)  // Size limit
       .expireAfterWrite(12, TimeUnit.HOURS)  // Time-based expiration
       .build(new CacheLoader<String, DataObject>() {
           @Override
           public DataObject load(String key) {
               return fetchDataFromDb(key);
           }
       });

Advanced Troubleshooting Techniques for Developers

1. Narrowing Down Problem Scope

Track issues to the point just before failure to pinpoint the exact cause of errors.

2. Understanding Environment Differences

Recognize differences between development, test, and production environments. Remote debugging can be valuable for non-local environments.

3. Implementing Effective Logging Strategy

Logs are critical troubleshooting tools. Develop a logging strategy that captures necessary information while avoiding excessive output.

4. Performance Profiling

Combine system-level analysis with code profiling to address performance issues:

// Performance profiling example
long start = System.nanoTime();
result = expensiveOperation();
long end = System.nanoTime();
log.info("Operation took {} ms", (end - start) / 1_000_000);

// Detailed bottleneck identification
Map<String, Long> timings = new HashMap<>();
timings.put("db_query", measureDbQueryTime());
timings.put("external_api", measureExternalApiTime());
timings.put("processing", measureProcessingTime());
log.info("Performance breakdown: {}", timings);

Effective Postmortem Documentation

After resolving issues, create effective postmortem documentation to prevent recurrences and share knowledge:

# Incident Postmortem: API Server 504 Timeout (2023-05-15)

## Issue Summary

- **Time**: 2023-05-15 14:20 ~ 16:45 UTC
- **Impact**: 30% payment API request failures, affecting ~500 users
- **Symptom**: HTTP 504 Gateway Timeout during payment processing
- **Root Cause**: Database connection pool exhaustion

## Timeline

- **14:20** - Alert: API response time increase
- **14:25** - Initial investigation, log analysis
- **14:40** - Root cause identified: DB connection shortage
- **15:00** - Interim fix: Connection pool expansion
- **16:45** - Permanent fix: Query optimization and connection management improvements

## Root Cause

Specific API failing to properly return DB connections, causing connection pool depletion
`code: UserService.java:120 - connection.close() missing`

## Resolution

1. **Short-term**: Increased connection pool size (50 → 100)
2. **Medium-term**: Implemented try-with-resources pattern for automatic resource release
3. **Long-term**: Added connection leak detection monitoring

## Prevention Measures

- Completed review of all DB connection management code
- Added connection pool monitoring alerts (80% usage threshold)
- Documented DB transaction management guidelines for the team

Conclusion

Troubleshooting is more than just fixing errors—it's about strengthening system resilience. By resolving issues, documenting solutions, and sharing knowledge, you establish preventive measures that continuously improve system stability and reliability.

Agile Scrum - The Easy Guide to Self-Learning

TEN — Wed, 28 May 2025 05:40:54 +0000

🛠️ Agile Scrum - The Easy Guide to Self-Learning

This guide has been prepared to support junior and mid-level developers in gaining a clear understanding of the Agile Scrum process, particularly in the context of collaborative team environments.

📋 What is Scrum?

Scrum is an Agile framework used to manage and complete complex projects. It emphasizes iterative progress, collaboration, and adaptability. The goal is to deliver a potentially shippable product increment at the end of each sprint (a short, time-boxed period).

🔄 Scrum Workflow

The Scrum workflow typically follows these steps, which are repeated in cycles (sprints) lasting 1-2 weeks:

Product Backlog

A prioritized list of features, enhancements, and bug fixes maintained by the Product Owner.
If you don't know what to do, just create backlog own your self and than ask your manager.
Sprint Planning

The team selects items from the Product Backlog to work on during the sprint. These items are added to the Sprint Backlog.
Sprint Backlog

A list of tasks the team commits to completing during the sprint.
Sprint Execution

The team works on the tasks in the Sprint Backlog. Daily Scrum meetings are held to ensure progress and address blockers.
Potential Product Increment

At the end of the sprint, the team delivers a potentially shippable product increment.
Sprint Review

The team demonstrates the completed work to stakeholders and gathers feedback.

👥 Roles in Scrum

we have 3 types role but if you're team is not big, you just only member and ask your manager when you ProductOwner and Scrum Master

Product Owner

Responsible for defining the vision of the product, managing the Product Backlog, and ensuring the team delivers value to the business.
Scrum Master

Facilitates the Scrum process, removes obstacles, and ensures the team follows Scrum principles.
Team Members

Developers, designers, and other contributors who work collaboratively to complete the tasks in the Sprint Backlog.

📂 Artifacts in Scrum

we have 3 types Artifacts.
if you not doing agile you just create backlog somewhare suchlike your notion, google document, jira
and than you just ask to check your manager
and than if you start to work, you can move your backlog some underplace that gonna be sprint back log

Product Backlog

A dynamic list of all desired work on the product, prioritized by the Product Owner.
Sprint Backlog

A subset of the Product Backlog selected for the sprint, along with a plan for delivering it.
Burndown Chart

A visual representation of the work remaining in the sprint, helping the team track progress.

🔔 Scrum Ceremonies

If you made or got backlog you have to know what is the first to do and what should we do
so we do plan

and than you can daily scrum because if you have some problem we have to know for product

if it end we share what is the problem and what is good. we grow up

Sprint Planning

A meeting where the team decides what work will be done in the upcoming sprint.
Daily Scrum

A short, time-boxed meeting (15 minutes) where team members discuss progress, plans, and blockers.
Sprint Review

A meeting at the end of the sprint to showcase the completed work and gather feedback.

🆚 Scrum vs. Traditional Waterfall

waterfall is not bad but its too hard change the plan
if you wanna agile move your project we can use scrum working process

Waterfall

Projects are planned in sequential phases (e.g., requirements, design, development, testing).
Each phase can take 3-6 months or more.
Changes are difficult to accommodate once a phase is completed.

Scrum
- Work is divided into short sprints (1-4 weeks).
- Continuous feedback and adaptability are key.
- Changes can be incorporated at the start of each sprint.

🧪 Solo Scrum – Practical Workflow Example

If you're working alone or with a small team but still want to practice Scrum principles:

Define a clear goal Set a tangible and achievable sprint objective (e.g., "Build MVP login system").
Create a backlog Break the goal down into actionable tasks and list them in your product backlog.
Estimate story points Assign story points to each backlog item based on complexity or effort.
Run the sprint & log your retrospective Execute the sprint, track progress daily, and write a brief sprint retrospective at the end.
Repeat the cycle Reflect, adjust, and start the next sprint with improvements in mind.

By following the Scrum process, teams can deliver high-quality products faster, adapt to changing requirements, and maintain better collaboration between stakeholders and developers.

DEV Community: TEN

Why Writing Still Matters — A Developer's Case for Thinking Out Loud

It Starts with Curiosity

Platform Migration: From Tistory to GitHub

Trying Other Platforms

Why I Write

Why English?

The Long Game

CI/CD with Jenkins, Docker & Git - A Simple Guide for Junior Developers

Easy CI/CD Setup with Jenkins, Docker & Git

What You'll Need

Overview

Step 1: GitHub Setup

Step 2: Local Development

Step 3: Server Setup

- Pro tip: Store this compose file in a GitHub repo for version control!

Step 4: Jenkins Configuration

Bonus: Easy Log Viewing with Dozzle

Wrapping Up

MySQL Performance Optimization

Complete Guide to MySQL Performance Optimization

Table of Contents

1. Scalability

Vertical Scaling

Read Replica Configuration

ProxySQL for Read/Write Separation

Sharding

2. Performance Optimization

Index Optimization

Slow Query Optimization

Connection Pooling

3. Data Consistency & High Availability

Replication

Automatic Failover

Backup and Recovery Strategy

4. Query Optimization

Using EXPLAIN Command

Query Rewriting

Pagination Optimization

5. Hardware & System Configuration

Server Resource Optimization

MySQL Configuration Optimization

OS Level Optimization

6. Partitioning

Table Partitioning

Partition Management

7. Advanced Optimization Techniques

Data Caching Strategies

Query Result Caching with Redis

Using Memory Tables

Large Data Processing Optimization

Batch Processing

Using Temporary Tables

Transaction Optimization

Limiting Transaction Size

Setting Isolation Levels

MySQL Optimization in Cloud Environments

AWS RDS Optimization

Monitoring and Performance Analysis

Data Compression and Archiving

Table Compression

Cold Data Archiving

8. Case Studies

Large Log Table Optimization

High-Traffic E-commerce Platform Optimization

9. New Features in MySQL 8.0+

Window Functions

Common Table Expressions (CTE)

Histogram Statistics

10. Key Performance Monitoring Metrics

Essential Monitoring Metrics

Monitoring Tools

Conclusion

References

Effective Troubleshooting - A Comprehensive Guide

Troubleshooting Guide for Developers

Overview: A Systematic Approach to Problem Solving

Basic Troubleshooting Flow

1. Problem Identification

2. Problem Reproduction