Forem: Shelner

Explanation of `Connection`, `DriverManager` and `SQLExeption` in Java

Shelner — Fri, 27 Mar 2026 04:52:15 +0000

1. `Connection`

Represents a live connection to your database
You use it to:
- execute SQL (SELECT, INSERT, etc.)
- manage transactions (commit, rollback) Think of it as: a session between your Java app and the DB.

A connection (session) with specific database. SQL statements are executed and results are returned within the context of a connection.

2. `DriverManager`

Responsible for creating the Connection
It:
- finds the correct JDBC driver (e.g., MySQL)
- opens the connection using URL, USER, PASSWORD Think of it as: a factory that gives you a Connection.

3. `SQLExeption`

An exception (error) thrown when something goes wrong with the database.
Exampls:
- wrong password
- database not running
- invalid SQL query Think of it as: a signal that DB operation failed

How they work together

Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);

DriverManager -> tries to connect
If success -> returns a Connection
If failure -> throws SQLException

DriverManager -> creates -> Connection -> used for DB work
                           ↑
                     may throw SQL Exception

Learning Terms in Java

Shelner — Tue, 03 Feb 2026 14:33:50 +0000

What is Reactive Programming?

Reactive Programming = "Don't wait. React when data arrives."

In normal (blocking) programming:

You ask for data
Your code waits
When data comes, the code continues

In Reactive Programming:

You say: "Hi, tell me when data is ready"
Your code does not wait
When data arrives, your code reacts

Think of it like:

Normal: You call someone and wait on the line
Reactive: You leave your number and get a callback

This is great for:

Web APIs
WebSockets
Streaming data
High-traffic systems

What is Reactor?

Reactor = a Java library that implements reactive programming

Made by the Spring team
Used in Spring WebFlux
Handles async, non-blocking streams

So:

Reactive Programming -> concept
Reactor -> Tool to use that concept in Java

Reactor mainly gives you:

Mono
Flux

What is Publisher?

Publisher = something that sends data
This comes from the Reactive Streams specification.

A Publisher:

Produces data
Sends data to subscribers
Can send:
- 0 items
- 1 item
- many items
- or an error

You usually don't implement Publisher itself.
Reactor already does that.

Mono and Flux are Publishers

What is `Mono`?

Mono = a Publisher that emits at most ONE value

Possible results:

1 value
no value
error

Examples:

Get one user by ID
Get account balance
Call an external API that returns one result

Example:

Mono<String> mono = Mono.just("Hello");

Think of Mono as:

"I promise to give you one result later (or nothing)."

What is `Flux`?

Just for completeness:
Flux = 0 to many values

Example:

Price stream
WebSocket messages
List of users

Flux<Integer> flux = Flux.just(1, ,2, 3);

Create Simple API using Express, Swagger UI

Shelner — Mon, 26 Jan 2026 05:05:42 +0000

// app/src/routes/user.routes.ts
import { Request, Response, Router } from "express";

const router = Router();

router.get("/", (req: Request, res: Response) => {
    res.json([
        { id: 1, name: "Alice" },
        { id: 2, name: "Bob" }
    ]);
});

export default router;

// app/src/app.ts
import express from "express";
import swaggerUi from "swagger-ui-express";
import YAML from "yamljs";
import userRoutes from "./routes/user.routes";

const app = express();
app.use(express.json());

// Routes
app.use("/api/users", userRoutes);

// Swagger
const swaggerDocument = YAML.load("./src/openapi.yaml");
app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocument));

const PORT = 3000;
app.listen(PORT, () => {
    console.log(`Server running on http://localhost:${PORT}`);
    console.log(`Swagger UI on http://localhost:${PORT}/api-docs`);
});

# app/src/openapi.yaml
openapi: 3.0.0
info:
  title: Simple User API
  version: 1.0.0
  description: A simple API using Node.js, TypeScript, and OpenAPI

servers:
  - url: http://localhost:3000

paths:
  /api/users:
    get:
      summary: Get all users
      responses:
        "200":
          description: List of users
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/User"

components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: number
        name:
          type: string

package.json

{
  "name": "simpleAPI",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "dev": "ts-node-dev --respawn src/app.ts",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "packageManager": "pnpm@10.15.1",
  "dependencies": {
    "express": "^5.2.1",
    "swagger-ui-express": "^5.0.1",
    "yamljs": "^0.3.0"
  },
  "devDependencies": {
    "@types/express": "^5.0.6",
    "@types/node": "^25.0.10",
    "@types/swagger-ui-express": "^4.1.8",
    "@types/yamljs": "^0.2.34",
    "ts-node-dev": "^2.0.0",
    "typescript": "^5.9.3"
  }
}

How to use

pnpm install
pnpm run dev

System Architecture Design Example using Mermaid

Shelner — Wed, 14 Jan 2026 07:35:39 +0000

flowchart TB
    %% Users
    User[User / Driver Browser]

    %% Frontend
    User -->|HTTPS| CloudFront
    CloudFront --> S3[S3<br/>React - SPA]

    %% API Access
    CloudFront -->|API Requests| ALB[Application Load Balancer]

    %% Kubernetes Cluster
    subgraph AWS_EKS[AWS EKS Cluster]
        ALB --> Ingress[Ingress Controller]

        subgraph Backend[Backend Services]
            Auth[Auth Service]
            UserSvc[User Service]
            DriverSvc[Driver Service]
            RideSvc[Ride Service]
            PaymentSvc[Payment Service]
        end

        Ingress --> Auth
        Ingress --> UserSvc
        Ingress --> DriverSvc
        Ingress --> RideSvc
        Ingress --> PaymentSvc
    end

    %% Datastores
    Auth --> MySQL[(MySQL)]
    UserSvc --> MySQL
    DriverSvc --> MySQL
    RideSvc --> MySQL
    PaymentSvc --> MySQL

    Auth --> Redis[(Redis)]
    RideSvc --> Redis
    DriverSvc --> Redis

    %% CI/CD
    subgraph CICD[CI / CD]
        GitHub[GitHub Repository]
        GHA[GitHub Actions]
    end

    GitHub --> GHA
    GHA -->|Build & Deploy| AWS_EKS
    GHA -->|Build & Upload| S3

Frontend

React: SPA
S3: Hosts static frontend assets
CloudFront: CDN, Routes API requests to backend

Backend

API Services
Kubernetes on EKS: Auto-scaling, self-healing microservices
Ingress Controller: Routes HTTP traffic to internal services
Docker: Containerized services for portability

Data Layer

MySQL: users, drivers, rides, payments
Redis: Caching & real-time data (driver locations, ride state, sessions)

CI/CD

GitHub Actions
- Frontend: build -> upload to S3 -> CloudFront cache invalidation
- Backend: build Docker images -> deploy to EKS

Password Generator using Go and K3s

Shelner — Sun, 04 Jan 2026 14:08:55 +0000

package main

import (
    "crypto/rand"
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const numbers = "0123456789"
const symbols = "!@#$%^&*()_+-="

func generatePassword(length int, useNumbers bool, useSymbols bool) (string, error) {
    charset := letters
    if useNumbers {
        charset += numbers
    }
    if useSymbols {
        charset += symbols
    }

    bytes := make([]byte, length)
    _, err := rand.Read(bytes)
    if err != nil {
        return "", err
    }

    for i := range bytes {
        bytes[i] = charset[int(bytes[i])%len(charset)]
    }
    return string(bytes), nil
}

func passwordHandler(w http.ResponseWriter, r *http.Request) {
    length, _ := strconv.Atoi(r.URL.Query().Get("length"))
    if length <= 0 {
        length = 12
    }

    useNumbers := r.URL.Query().Get("numbers") == "true"
    useSymbols := r.URL.Query().Get("symbols") == "true"

    password, err := generatePassword(length, useNumbers, useSymbols)
    if err != nil {
        http.Error(w, "Failed to generate password", 500)
        return
    }

    response := map[string]string{
        "password": password,
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

func main() {
    http.HandleFunc("/api/password/generate", passwordHandler)

    fmt.Println("Server running on :8080")
    http.ListenAndServe(":8080", nil)
}

How to use

Run : go run main.go
Server running on :8080
Access: http://localhost:8080/api/password/generate http://localhost:8080/api/password/generate?length=20&numbers=true&symbols=true

K3s Architecture

I deployed this project using K3s on Ubuntu22.

k3s is a lightweight Kubernetes distribution for running production-ready clusters on resource-limited servers.

K3s server setup guide using Ubuntu22

Shelner — Sat, 03 Jan 2026 12:26:34 +0000

I explain what each command does and focusing on k3s and Kubernetes concepts.

Set up Ubuntu

Login using SSH
Update & Install tools: sudo apt update && sudo apt install -y curl vim git

Disable Swap (Required for Kubernetes)

sudo swapoff -a

swap: Disk space used as virtual memory.
Why disable swap? Kubernetes requires swap to be disabled because it expects full control over memory management.

sudo sed -i '/ swap / s/^/#/' /etc/fstab

/etc/fstab: File that defines filesystems mounted at boot.
sed -i: Edits the file in place.
This command comments out swap entries, so swap stays disabled after reboot.

Install K3s

curl -sfL https://get.k3s.io | sh -

curl -sfL:
- -s: silent
- -f: fail on error
- -L: follow redirects
https://get.k3s.io: Official k3s installation script.
| sh -: Pipes the script directly into the shell and executes it.

This installs:

K3s server
containerd
kubectl (boundled)

Check K3s Service

sudo systemctl status k3s

status k3s: Confirms that the k3s server is running correctly.

Set kubeconfig

export KUBECONFIG=/etc/rancher/k3s/k3s.yaml

KUBECONFIG: File that tells kubectl how to connect to the cluster.
/etc/rancher/k3s/k3s.yaml: Default kubeconfig generated by k3s.

※Without this, kubectl may not work for non-root users.

Verify Cluster

sudo kubectl get nodes

kubectl: Kubernetes command-line tool.
get nodes: Shows all nodes in the cluster.
Output confirms:
- k3s is running
- this VM is acting as a control-plane + worker node

Create Nginx Pod

vim ~/nginx-pod.yaml

Pod Yaml

apiVersion: v1
kind: Pod
metadata:
  name: hi-nginx
spec:
  containers:
  - name: nginx
    image: nginx:stable-alpine
    ports:
    - containerPort: 80

Explanation

apiVersion: v1: Core Kubernetes API.
kind: Pod: Smallest deployable unit in Kubernetes.
metadata.name: Pod name.
spec.containers: List of containers inside the pod
image: nginx:stable-alpine: Lightweight Nginx image
containerPort: 80: Port exposed inside the container.

Create Pod

sudo kubectl apply -f ~/nginx-pod.yaml

apply: Creates or updates resources declaratively.
-f: Uses the YAML file.

Check Pods

sudo kubectl get pods

Shows pod status (Running, Pending, etc.).

Organaize Files

mkdir ~/k3s-pod
mv ~/nginx-pod.yaml ~/k3s-pod/
cd ~/k3s-pod/

Creates a directory to organize Kubernetes manifests.

Create Service (NodePort)

vim ~/k3s-pod/nginx-service.yaml

Service YAML

apiVersion: v1
kind: Service
metadata:
  name: nginx-svc
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30090

Explanation:

kind: Service: Exposes pods to the network.
type: NodePort: Opens a port on every node's IP.
selector: Finds pods with label app=nginx.
port: Service port.
targetPort: Container port.
nodePort: 30090: External port accessible via NodeIP:30090.

Add Label to Pod

sudo kubectl label pod hi-nginx app=nginx

Labels are key-vakye pairs used by Services and Deployments.
Required so the Service can find the Pod.

Create Service

sudo kubectl apply -f ~/k3s-pod/nginx-service.yaml

Find IP Address

ip a

Shows network interfaces.
eth0 usually holds the node IP.

Private IP Ranges

10.0.0.0 - 10.255.255.255
172.16.0.0 - 172.31.255.255
192.168.0.0 - 192.168.255.255

These are private IP addresses.
Not reachable directly from the internet.

Access Nginx

curl http://10.140.11.1:30090

Access Nginx via:
- Node.IP
- NodePort

You can laso use:

curl http://<HOST_NAME>:30090
curl http://<Global_IP>:30090

Create Deployment

vim ~/k3s-pod/nginx-deploy.yaml

Deployment YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deploy
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:stable-alpine
        ports:
        - containerPort: 80

Explanation:

kind: Deployment: Manages Pods automatically.
replicas: 3: Runs 3 indentical pods.
selector.matchLabels: Connects Deployment <-> Pods
template: Pod definition used by Deployment.

Deploy Deployment

sudo kubectl apply -f ~/k3s-pod/nginx-deploy.yaml

Check Deployment & Pods

sudo kubectl get deployments,pods

Confirms:
- All replicas are running
- Deployment is healthy

Rolling Update

vim ~/k3s-pod/nginx-deploy.yaml

Change image version:

image: nginx:1.21-alpine

sudo kubectl apply -f nginx-deploy.yaml
sudo kubectl rollout status deployment/nginx-deploy

Rolling update:
- Old pods are replaced gradually
- Zero downtime
rollout status: Shows update progress.

Summary

You have successfully learned:

k3s installation
Pod vs Deployment
Service (NodePort)
Labels & selectors
Rolling updates
Accessing services from outside the cluster

Terms for Web Technologies 1

Shelner — Wed, 31 Dec 2025 10:22:58 +0000

Redis

Redis is an in-memory data store (key-value database).

It's used:

Extremely fast (RAM-based)
Caching data to reduce DB load
Session storage
Rae limiting

Common use cases:

Cache API responses
Store login sessions
Leaderboards, counters

Travis CI

TravisCI is a CI (Continuous Integration) service.

It's used:

Automatically runs tests on every GitHub push or PR
Simple YAML-based configuration

Typical flow:

git push -> Travis CI -> run tests -> report result

CircleCI

This is a CI/CD platform (more powerful than Travis CI).

It's used:

Fast builds
Parallel jobs
Advanced workflows
Docker-first support

Typical use:

Test -> build -> deploy pipelines

OpenAPI

OpenAPI is a standard specification for describing REST APIs.

It's used:

API documentation
Auto-generate client/server code
API validation

Very important for team development and public APIs.

RabbitMQ

It is a message broker.

It's used:

Asynchronous communication: the sender does not wait for the receiver to finish processing.
Decoupling services: don't directly depend on each other.
- Order Service → Message Broker → Email Service
- Not Order Service → Email Service (direct API call): If Email Service is down -> Order Service fails.
Reliable message delivery

Typical pattern:

Producer -> RabbitMQ -> Consumer

Best for:

Background jobs
Email sending
Task queues

Kafka

It is a distributed event streaming platform.

It's used:

High-throughput event processing
Real-time data pipelines
Log aggregation

RabbitMQ vs Kafka:

RabbitMQ -> task queues
Kafka -> event streams & big data

Used heavily in large-scale systems.

Elasticsearch

It is a search and analytics engine.

It's used:

Full-text search
Fast filtering and aggregation
Log searching

Common use cases:

Website search
Log analysis
Analytics dashboards

Often used with Kibana.

ElastiCache (AWS)

It is AWS-managed Redis or Memcached service.

It's used:

No server management
High availability
Auth scaling

Use cases:

Session cache
API caching
Leaderboards

Basically Redis on AWS, production-ready.

Fluentd

It is a log collection and forwarding tool.

It's used:

Collect logs from many sources
Normalize log formats
Send logs to Elcasticsearch, BigQuery, S3, etc.

Typical flow:

App logs -> Fluentd -> Elasticsearch

Essential in Kubernetes environments.

gRPC

It is a high-performance RPC framework by Google.

It's used:

Faster than REST
Strongly typed (Protocol Buffers)
Efficient binary communication

Best for:

Microservices
Internal service-to-service communication

Less human-readable than REST, but very fast.

BigQuery

It is Google Cloud's serverless data warehouse.

It's used:

Analyze huge datasets.
SQL-based analytics
No infrastructure management

Use cases:

Business analytics
Log analysis
Data science

Ideal for bit data, not transactional workloads.

Sentry

It is an error monitoring tool.

It's used:

Capture runtime errors
Stack traces
User impact tracking

Supports:

Frontend (React, Vue)
Backend (Node.js, Java, Go)

Helps you fix bugs faster.

New Relic

It is an application performance monitoring (APM) platform.

It's used:

Monitor performance
Trace slow APIs
Infrastructure metrics
Alerts

Tracks:

Response time
Database queries
Memory / CPU usage

Used for production obervability.

Example Architecture

Frontend (React)
 ↓
API (Node / Java) | Redis / ElastiCache (cache)
 ↓
Database (MySQL)
 ↓
RabbitMQ / Kafka (async events)

Logs -> Fluentd -> Elasticsearch
Errors -> Sentry
Performance -> New Relic
CI/CD -> CercleCI
API Spec -> OpenAPI

How to deploy Next.js App to VPS (Ubuntu server) with GitHub-Actions

Shelner — Tue, 30 Dec 2025 14:43:00 +0000

Explain How to deploy a Next.js Application to an ubuntu server (VPS) using GitHub Actions (private repository), NginX, and SSL (Let's Encrypt).

Overall Architecture

GitHub (private repository)
   ↓ GitHub Actions 
Ubuntu VPS
  - Node.js (Next.js build & run)
  - PM2 (process manager)
  - Nginx 
  - Let's Encrypt (SSL)

Prepare the Ubuntu

Update system

sudo apt update && sudo apt upgrade -y

Set SSH setting

cd /etc/ssh/
vim /etc/ssh/sshd_config

set the following rules

Port 2222 # any
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
GatewayPorts no

Set ufw

sudo ufw limit 2222/tcp # ssh port
sudo ufw allow 80/tcp # http
sudo ufw allow 443/tcp # hppts
sudo ufw enable
sudo ufw status verbose # checking
sudo ufw reload

install required packages

sudo apt install -y git nginx

Install Node.js

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs
node -v
npm -v

Create a Deployment User

sudo adduser deploy
sudo usermod -aG sudo deploy
su - deploy

Clone the private GitHub Repository (SSH)

On VPS: create SSH key

mkdir -p /home/deploy/.ssh
chmod 700 /home/deploy/.ssh

# no passphrase <- this is important
ssh-keygen -t ed25519 -C "deploy@server"
cat ~/.ssh/id_ed25519.pub

Add this public key to:

GitHub -> Next.js Repository -> Setting -> Deploy keys

Test:

ssh -T git@github.com

If you create something other than id_ed25519, set this:

vim ~/.ssh/config

Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/your_ssh_file_name
    IdentitiesOnly yes

chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/your_ssh_file_name
chmod 644 ~/.ssh/your_ssh_file_name.pub
ssh -T git@github.com

Clone the repository

mkdir ~/app
chmod 755 ~/app/
cd ~/app
git clone git@github.com:USERNAME/Repository.git
cd Repository
chmod 755 ~/app/Repository

Install pnpm and Dependencies & Build Next.js app

sudo corepack enable
corepack prepare pnpm@latest --activate
pnpm -v
pnpm install
pnpm run build
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts
nvm use --lts
npm install -g pm2
pm2 start npm --name "mynextjs" --start
pm2 save
pm2 startup

Configure Nginx

Create Nginx config

sudo nano /etc/nginx/sites-available/nextjs

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

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Enable:

sudo ln -s /etc/nginx/sites-available/sub.example.com /etc/nginx/sites-enabled/
sudo nginx -t
sudo rm /etc/nginx/sites-enabled/default
sudo systemctl reload nginx

※Caution
Your VPS Sometimes uses packet filter.
If it uses packet filter, you have to allow ports that are 2222, 80 and 443.

Enable SSL with Let’s Encrypt

Install Certbot

sudo apt install -y certbot python3-certbot-nginx

Issue certificate

sudo certbot --nginx -d sub.example.com

Auto-renew test:

sudo certbot renew --dry-run

GitHub Actions

on Local your PC

cd ~/.ssh
ssh-keygen -t ed25519 -C "github-actions"
cat ~/.ssh/for-github-actions.pub

Access GitHub Web -> Your Repository on GitHub -> Settings -> Secrets and variables -> Actions -> New Repository secret -> Name SSH_PRIVATE_KEY

Private key → GitHub Secrets (SSH_PRIVATE_KEY)
Public key → ~deploy/.ssh/authorized_keys

Also set the following variables on GitHub:

paste private key as `SSH_PRIVATE_KEY`
set `SSH_HOST`` -> 111.111.111.111 (Your VPS IP Address)
set `SSH_USER` -> deploy
set `SSH_PORT` -> 2222

On your Next.js app, create this:

`.github/workflows/deploy.yml`

name: Deploy Next.js

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup SSH
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
          chmod 600 ~/.ssh/id_ed25519
          ssh-keyscan -p "${{ secrets.SSH_PORT }}" -H "${{ secrets.SSH_HOST }}" >> ~/.ssh/known_hosts

      - name: Deploy
        run: |
          ssh -i ~/.ssh/id_ed25519 "${{ secrets.SSH_USER }}"@"${{ secrets.SSH_HOST }}" -p "${{ secrets.SSH_PORT }}" << 'EOF'
            export NVM_DIR="$HOME/.nvm"
            source "$NVM_DIR/nvm.sh"

            cd /home/${{ secrets.SSH_USER }}/app/Repository
            git pull origin main
            pnpm install
            pnpm run build
            pm2 restart mynextjs
          EOF

Gitflow and GitHub-flow

Shelner — Mon, 29 Dec 2025 05:31:47 +0000

Gitflow

Gitflow is a branching model designed for structured releases and long-term maintenance.

Main Branches

main (or master) Always contains production-ready code
develop Integration branch for completed features before a release.

Supporting branches

feature/* Created from develop for new features.
release/* Created from develop to prepare a release (bug fixes, version bumps, Documentation).
hotfix/* Created from main to quickly fix production bugs.

Typical flow

Create feature/* from develop
Merge feature into develop
Create release/* from develop
Merge release into main and develop
Tag the release
Use hotfix/* if production issues occur

Pros (Advantage)

Clear separation of development, release, and production
Good for large teams and scheduled releases
Works well with versioned software

Cons (Disadvantage)

Complex
Heavy branching and merging
Slower for continuous deployment

Best for

Enterprise systems
Products with fixed release cycles
Teams needing strict control

GitHub Flow

GitHub Flow is a lightweight workflow optimized for continuous deployment.

Main branch

main Always deployable

Branches

Feature branches Created directly from main and merged back via Pull Requests.

Typical flow

Create a branch from main
Make changes and commit
Open a Pull Request
Review, test, CI runs
Merge into main
Deploy immediately

Pros

Simple and fast
Easy to understand
Excellent for CI/CD
Fewer merge conflicts

Cons

Not ideal for long release preparation
Requires strong testing and CI discipline

Best for

Web applications
SaaS products
Small to medium teams
Continuous deployment environments.

Key Differences

Aspect	Gitflow	GitHub Flow
Complexity	High	Low
Branches	Many	Few
Releases	Scheduled	Continuous
CI/CD	Optional	Essential
Best use	Large, structured projects	Modern web & SaaS apps

[UI Design] Markdown Viewer

Shelner — Mon, 03 Nov 2025 03:14:47 +0000

Markdown Viewer for blog

Left side: Menu bar: blog title
Right side: Display content with markdown

Reverse Integer

Shelner — Sun, 02 Nov 2025 13:57:18 +0000

Solution code

public class ReverseInteger {
    public int reverse(int x) {
        int min = Integer.MIN_VALUE; // -2,147,483,648
        int max = Integer.MAX_VALUE; //  2,147,483,647
        if (x == min || x == max) return 0;
        int reversed = 0;
        while (x != 0) {
            int lastDigit = x % 10;
            if (reversed > max/10) return 0;
            if (reversed < min/10) return 0;
            reversed = reversed * 10 + lastDigit;
            x = x / 10;
            System.out.println("lastDigit: " + lastDigit + ", reversed: " + reversed + ", x: " + x);
        }
        return reversed;
    }
}

Test code

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class ReverseIntegerTest {
    ReverseInteger reverseInteger = new ReverseInteger();

    @Test
    void testPositiveNumber() {
        assertEquals(321, reverseInteger.reverse(123));
    }

    @Test
    void testNegativeNumber() {
        assertEquals(-321, reverseInteger.reverse(-123));
    }

    @Test
    void testNumberWithTrailingZeros() {
        assertEquals(21, reverseInteger.reverse(120));
    }

    @Test
    void testPositiveLimit() {
        assertEquals(1463847412, reverseInteger.reverse(2147483641));
    }

    @Test
    void testNegativeLimit() {
        assertEquals(-2147483641, reverseInteger.reverse(-1463847412));
    }

    @Test
    void testOverflowPositive() {
        assertEquals(0, reverseInteger.reverse(1534236469)); // overflow int
    }

    @Test
    void testOverflowNegative() {
        assertEquals(0, reverseInteger.reverse(-2147483642));
    }

    @Test
    void testOverflowPositiveLimit() {
        assertEquals(0, reverseInteger.reverse(2147483647));
    }

    @Test
    void testOverflowNegativeLimit() {
        assertEquals(0, reverseInteger.reverse(-2147483648));
    }

    @Test
    void testZero() {
        assertEquals(0, reverseInteger.reverse(0));
    }
}

Solution code (TS)

function reverse(x: number): number {
    const min = -2147483648;
    const max = 2147483647;
    if (x === min || x === max) return 0;
    let reversed = 0;
    while (x !== 0) {
        const lastDigit = Math.trunc(x % 10);
        if (reversed > max / 10) return 0;
        if (reversed < min / 10) return 0;
        reversed = reversed * 10 + lastDigit;
        x = Math.trunc(x / 10); // ✅ truncates toward zero
    }
    return reversed;
}

Factorial Trailing Zeros

Shelner — Sat, 01 Nov 2025 15:59:11 +0000

Solution code (Java)

public class FactorialTrailingZeros {
    public static int trailingZeros(int num) {
        int result = 0;
        int crrPowerOfFive = 5; // 5, 25, 125, 625, ...
        while (num >= crrPowerOfFive) {
            result += num / crrPowerOfFive;
            crrPowerOfFive *= 5;
        }
        return result;
    }
}

Test Code (JUnit)

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class FactorialTrailingZerosTest {
    @Test
    void test3() {
        int testData = 3;
        int expected = 0;
        int result = FactorialTrailingZeros.trailingZeros(testData);
        assertEquals(expected, result);
    }

    @Test
    void test5() {
        int testData = 5;
        int expected = 1;
        int result = FactorialTrailingZeros.trailingZeros(testData);
        assertEquals(expected, result);
    }

    @Test
    void test24() {
        int testData = 24;
        int expected = 4;
        int result = FactorialTrailingZeros.trailingZeros(testData);
        assertEquals(expected, result);
    }

    @Test
    void test125() {
        int testData = 125;
        int expected = 25 + 5 + 1;
        int result = FactorialTrailingZeros.trailingZeros(testData);
        assertEquals(expected, result);
    }
}

Solution Code (TypeScript)

export function factorialTrailingZeros(num: number): number {
    let count = 0;
    let crrPowerOfFive = 5;
    while (num >= crrPowerOfFive) {
        count += Math.floor(num / crrPowerOfFive);
        crrPowerOfFive *= 5;
    }
    return count;
}

Test Code (Jest)

describe("factorialTrailingZeros", () => {
    test("should return 0 for n = 0", () => {
        expect(factorialTrailingZeros(0)).toBe(0);
    });

    test("should return 0 for n = 4", () => {
        expect(factorialTrailingZeros(4)).toBe(0);
    });

    test("should return 1 for n = 5", () => {
        expect(factorialTrailingZeros(5)).toBe(1);
    });

    test("should return 6 for n = 25", () => {
        expect(factorialTrailingZeros(25)).toBe(6);
    });

    test("should return 31 for n = 125", () => {
        expect(factorialTrailingZeros(125)).toBe(31);
    });
});

Forem: Shelner

Explanation of `Connection`, `DriverManager` and `SQLExeption` in Java

1. Connection

2. DriverManager

3. SQLExeption

How they work together

Learning Terms in Java

What is Reactive Programming?

What is Reactor?

What is Publisher?

What is Mono?

What is Flux?

Create Simple API using Express, Swagger UI

How to use

System Architecture Design Example using Mermaid

Frontend

Backend

Data Layer

CI/CD

Password Generator using Go and K3s

How to use

K3s Architecture

K3s server setup guide using Ubuntu22

Set up Ubuntu

Disable Swap (Required for Kubernetes)

Install K3s

Check K3s Service

Set kubeconfig

Verify Cluster

Create Nginx Pod

Pod Yaml

Create Pod

Check Pods

Organaize Files

Create Service (NodePort)

Service YAML

Add Label to Pod

Create Service

Find IP Address

Private IP Ranges

Access Nginx

Create Deployment

Deployment YAML

Deploy Deployment

Check Deployment & Pods

Rolling Update

Summary

Terms for Web Technologies 1

Redis

Travis CI

CircleCI

OpenAPI

RabbitMQ

Kafka

Elasticsearch

ElastiCache (AWS)

Fluentd

gRPC

BigQuery

Sentry

New Relic

Example Architecture

How to deploy Next.js App to VPS (Ubuntu server) with GitHub-Actions

Overall Architecture

Prepare the Ubuntu

Update system

Set SSH setting

Set ufw

install required packages

Install Node.js

Create a Deployment User

Clone the private GitHub Repository (SSH)

On VPS: create SSH key

Clone the repository

Install pnpm and Dependencies & Build Next.js app

Configure Nginx

Create Nginx config

Enable SSL with Let’s Encrypt

Install Certbot

Issue certificate

1. `Connection`

2. `DriverManager`

3. `SQLExeption`

What is `Mono`?

What is `Flux`?

`.github/workflows/deploy.yml`