關於網路那些事...

A Multi-module Maven Project is a software architecture pattern that allows developers to split a large project into multiple interconnected sub-modules, all managed by a single parent project.

This parent-child Maven structure aligns well with microservices architecture. For example, a parent project can contain gateway and auth-service sub-modules. After packaging, these two modules can be deployed and maintained separately.

It’s important to note that this parent-child relationship is for build management, not a functional hierarchy. The parent POM centralizes dependency management, but it doesn’t mean gateway necessarily depends on auth-service.

Programmatic Dependencies: If the gateway module needs to use classes from auth-service, you would add a dependency in its pom.xml. However, in a typical microservices setup, gateway and auth-service communicate via HTTP APIs or OAuth tokens, eliminating the need for a direct JAR dependency.

A typical multi-module project structure in Maven looks like this:

workspace/
 ├─ pom.xml           <-- Parent POM, defines dependencyManagement, pluginManagement, versions
 ├─ gateway/          <-- Child module
 │   └─ pom.xml
 └─ auth-service/     <-- Child module
     └─ pom.xml

In a microservices architecture, service health checks and a reliable Linux deployment process are key to operational stability. This article will share how to build a health check interface in Spring Boot, combined with version management, and how to deploy and manage a Spring Boot JAR in a Linux environment to achieve automated execution and monitoring.

This article will explain how to build a health check interface in Spring Boot, manage versions using Maven BuildProperties, and use a Makefile for streamlined operations, automating the process from development to deployment. Finally, it will cover running the JAR on Linux and managing it with Supervisor.

What is MyBatis?

MyBatis is a first-class persistence framework that provides an alternative to traditional Object-Relational Mapping (ORM) solutions like Hibernate or JPA. Often referred to as a “SQL Mapper,” MyBatis distinguishes itself by embracing SQL. Instead of abstracting SQL away, it puts developers in full control, mapping SQL statements to Java methods.

The core philosophy of MyBatis is to decouple SQL from application logic while allowing you to leverage the full power of your database. It achieves this by mapping:

• Result Mapping: The results of a SQL query to Java objects.
• Parameter Mapping: Java objects and parameters to SQL statement placeholders.

This approach makes MyBatis an excellent choice for projects that require precise control over SQL, such as financial systems, high-performance transaction platforms, or applications with complex, performance-sensitive queries.

In a Spring Boot ecosystem, MyBatis can be integrated primarily in two ways:

1. Mapper Interface + XML (Recommended): Offers maximum flexibility for writing and maintaining complex SQL.
2. Mapper Interface + Annotations: Suitable for simple queries and smaller projects.

In modern application development, secure authentication and authorization are crucial components. This article demonstrates how to implement a Login Service using:

• Spring Boot (REST API, MVC pattern)
• Spring Security + Authorization Server (OAuth2.1)
• MyBatis (database persistence)
• MySQL (user and token storage)

The system acts as:

1. OAuth2 Authorization Server (issue JWT access tokens & refresh tokens).
2. OAuth2 Client (support login with Google in the future).
3. Resource Server validator (other services can validate tokens issued here).

在前兩篇文章中，我們成功建立了一個完整的三層架構應用：MySQL、Redis 和 Golang 後端服務，並將它們部署到 GKE 上。然而，手動部署在實際開發中並不實用，特別是當團隊規模擴大或需要頻繁發布時。這篇文章將介紹如何建立一個完整的 CI/CD 流程，實現程式碼變更後的自動測試、建置、部署和更新。

在上一篇文章中，我們成功使用 Helm 將 Nginx 部署到 GKE 上。這次，我們將更進一步，建立一個完整的三層架構應用：包含 MySQL 資料庫、Redis 快取服務，以及一個 Golang 後端應用。這個實作將更貼近實際的生產環境部署需求。

最近進到新專案，需要開始熟悉 GCP 相關服務，順手先嘗試將一個 Nginx 應用部署到 Google Kubernetes Engine (GKE) 上。過程中，使用 Helm 來簡化與管理部署流程，將過程記錄下來分享。

In this article, we will explore how to use the Gemini CLI to develop a 2D English word game by integrating it with Context 7 and Task Master AI. This setup allows for efficient task management and access to the latest documentation, enhancing the development process.

Find the game demo here: Word Cloud Shooter

When developing software—especially as codebases grow to thousands or even tens of thousands of lines—developers often encounter hard-to-fix bugs, or fixing one issue may introduce new problems. Even simple projects can require significant time to implement all desired features. Many existing AI programming tools, such as Cursor, are limited by their context window, typically supporting only about 10K tokens, which is roughly 400 to 600 lines of standard Python code. This short context length restricts the AI’s understanding of the entire project, making it difficult to identify key dependencies and architectural information. As a result, these tools can only handle single files or small-scale projects.

Introduction

This article provides a guide on how to install and configure the Google Cloud SDK (gcloud) on a Mac, including how to authenticate, create projects, set regions and zones, and manage Google Cloud Storage (GCS) buckets and objects using gcloud and gsutil commands.

In this post, I’ll share how I built a classic 2048 game from scratch by combining the Vibe Coding workflow with Roo Code’s AI-powered collaborative development features. Through real project steps, practical tips, and personal notes, you’ll get a glimpse of what modern AI-assisted development feels like — and how it points toward a future where developers and AI co-create software seamlessly.

Check out the live demo here: https://game-2048.hoohoo.top/

What is Vibe Coding?

Vibe Coding is an emerging development methodology that emphasizes visualization, real-time interaction, and AI collaboration. The goal is to lower the barrier to entry for coding, shorten development cycles, and improve code quality all at once.

Recently, we received AWS notifications that certain Node.js 18.x runtimes for our Lambda functions are approaching EOL and need to be upgraded. As part of our standard process, we first validate the new runtime locally before performing the actual update.

We’ve encountered issues where macOS on Apple Silicon (M1/M2) cannot reliably run Node.js 20.x. To work around this, we perform our runtime tests directly in AWS CloudShell. Since CloudShell does not support host.docker.internal for Docker networking, we’ve documented a workaround here.

Improving single-node performance in Node.js is a common challenge developers face, as Node.js’s single-threaded nature can limit its ability to handle high concurrency or heavy load in some applications. To enhance performance, you can consider a variety of solutions and techniques. Below are some common methods:

Using Multi-process or Multi-threading Techniques

(1) Node.js Cluster Module: The cluster module in Node.js allows for multi-process applications, enabling each CPU core to run a separate Node.js process. This can significantly improve the application’s concurrency performance.

(2) Worker Threads: The built-in Worker Threads in Node.js help you take advantage of multi-core CPUs for parallel computation. You can use Worker Threads to handle long-running computational tasks without blocking the main thread, thereby enhancing concurrency handling.

(3) PM2 for Monitoring and Multi-process Management: Using PM2 to configure multi-process mode for starting and managing Node.js processes can improve the application’s stability and resilience. PM2 automatically handles process restarts, load balancing, and other settings, making it easier to manage Node.js applications in production.

In this article, we will focus on introducing the Cluster module.

When designing a caching solution in Redis for a one-to-many relationship, such as a quiz with multiple member answers, it’s important to choose the right data structures to ensure efficient storage and retrieval. Redis offers several data structures that can be used to achieve this, including hashes and sets. Below, we discuss two common approaches: using hashes and using sets combined with hashes.

Introduction

Grafana K6 is a highly efficient load testing tool built with JavaScript (with a Golang core) that maximizes the load capabilities of a single machine. According to the official documentation, a single K6 process can effectively utilize all CPU cores, and under ideal conditions, it can simulate 30,000–40,000 virtual users (VUs). This is typically sufficient to handle 100,000–300,000 requests per second (RPS), translating to 6–12 million requests per minute. It enables more efficient load testing without requiring additional hardware resources.

In MySQL, both LEFT JOIN and FOREIGN KEY serve different purposes and come with their own advantages and disadvantages.

The decision on which to use depends on your needs regarding flexibility, data integrity, and performance. Let’s break down each approach:

When developing and optimizing MySQL databases, we often face the choice of using JSON fields or relational tables to manage data. This article will explore performance optimization methods for using JSON fields and relational tables in MySQL.

The advantages of JSON fields are compact data structure, reduced number of tables, and fewer join operations. However, parsing JSON fields incurs significant overhead, has limited index support, and may have lower query efficiency on large datasets.

The advantages of relational tables are clear relationship models, comprehensive index support, and efficient query optimization. However, it requires additional tables and join operations, which are typically efficient in relational databases.

In scenarios with millions and tens of millions of users, what are the advantages and disadvantages of these two approaches in terms of efficient querying and flexibility? Here are the considerations:

Scenario: A membership system that allows members to create organizations and share them with other members. In the struct of Organization, Permissions are used to record member IDs and roles. Under the organization, the ability to add courses and units while allowing member sharing at different levels needs to be maintained.

Casbin is an authorization library that supports access control models like ACL, RBAC, ABAC for muti-language.

Before developing Casbin, it is necessary to understand the underlying basic model and how to configure a permission management model that suits your needs.

First, the casbin model are base on PERM (Policy, Request, Effect, Matchers) with following settings:

• sub (subject): The entity accessing the resource, such as a member, user, or device. It represents who is making the request.
• obj (object): The resource being requested, such as a feature, page, or folder. It represents what is being requested.
• act (action): The method or behavior of the request, such as publish, edit, view, disable, etc. It represents how the request is made.
• eft (effect): The result of the policy after defining the sub, obj, and act. It can be set as true, false, or null (indicating allow).

And further, it can be combined with roles to manage roles or multi-tenancy.

Next, we will explain the Casbin model. During the learning process, you can practice and operate in the Casbin official editor.

Viper is a complete configuration solution for Go applications. It is designed to work within an application, and can handle all types of configuration needs and formats. Also, viper has many features, such as support for different configuration formats (JSON, TOML, YAML, etc.), live watching and re-reading of config files, reading from environment variables, etc.

Here will demostract how to use viper with local config, management with struct, and envrionment variables.

Singleton Design Pattern

The Singleton pattern is a creational design pattern that ensures a class has only one instance and provides a global access point to it.

In software development, there are situations where we need to restrict the instantiation of a class to a single object. This is particularly useful when dealing with shared resources or managing global state.

The Singleton pattern is implemented by defining a class with a private constructor and a static method. The first time the static method is called, it creates a new instance of the class. In subsequent calls, it returns the existing instance.

The Singleton pattern provides the following benefits:

• Ensures that there is only one instance of a class in the application.
• Provides a global access point to that instance.
• Delays the initialization of the instance, improving performance and resource utilization.

The following are two implementations of the Singleton pattern in Go, each demonstrating how to connect to a database: