Blog
Articles, guides, and notes on software engineering.
Learning Software Structure and Design from Clean Architecture Experts
A review of Clean Architecture. Rather than giving a strict definition, it describes the traits and rules of a design that can be called clean. It frames the goal of software architecture as minimizing the people needed to build and maintain a system, explaining dependency inversion through polymorphism and independent deployability and developability.
Recent Posts
ER Diagram Relationship Types: Dependent, Independent, and Many-to-Many
Understand the three types of ER diagram relationships: dependent (parent-child, solid line), independent (dotted line), and many-to-many. Includes SQL table design examples for each.
How to Read and Set Linux Permissions
A summary of how Linux permissions work. It covers how to read permission strings, including the leading file-type character and the rwx (read, write, execute) bits shown in three-character groups for owner, group, and others, as well as numeric notation and practical use of the chmod command.
MySQL JOIN vs UNION: Differences, Use Cases, and Examples
Learn the difference between MySQL JOIN and UNION with practical SQL examples. Covers INNER JOIN, LEFT JOIN, FULL OUTER JOIN, and how to combine result sets correctly.
Starting Algorithms with JavaScript
Master fundamental JavaScript algorithms including linear and binary search, plus selection and bubble sort implementations.
Understanding System Performance Through Illustrations
A review of Understanding System Performance Through Illustrations. A book that clearly explains the basics of system performance with diagrams. From how to think about bottlenecks onward, it helps you build a foundation for performance-aware design and tuning.
Unix Command Notes
Master Unix commands including jq for JSON processing, lsof for monitoring, and nmap for network port analysis.
Processes vs Threads: Key Differences Every Developer Should Know
Understand the key differences between processes and threads—memory isolation, context switching costs, and when to use multi-processing vs multi-threading in your code.
What is GraphQL
Understand GraphQL as a query language for APIs with flexible data selection, single endpoint, and type system advantages.
Starting Live Coding with Atom×TidalCycles×SuperCollider
Create music through live coding using Atom editor, TidalCycles language, Haskell functions, and SuperCollider sound synthesis engine.
Setting Up a Docker Environment on Sakura VPS
Step-by-step guide to installing Docker CE on Sakura VPS running CentOS. Covers yum repository setup, stable vs. edge channel configuration, and Docker CE installation commands.
Challenges Faced When Building an SPA
Fix SPA routing and resource path issues with nginx try_files configuration for single-page application development.
DI and Service Locator
Implement dependency injection patterns. Compare DI and Service Locator with constructor injection examples for loosely coupled code.
Symbolic Links vs Hard Links: Key Differences on Linux
Understand the difference between symbolic (soft) links and hard links on Linux. Learn about inodes, how each link type behaves on deletion, and practical use cases.
Getting Started with tmux
Discover tmux terminal multiplexer essentials with keybindings for sessions, windows, panes, and copy mode operations.
Revamping My Development Environment to be Vim-like
Streamlining development efficiency by integrating Vim and refreshing the development environment.
The UNIX Philosophy
A review of The UNIX Philosophy. A book that distills the thinking and philosophy behind UNIX into just 150 pages. Packed with ideas applicable to coding and design in general, like small is beautiful, it is something you will want to revisit whenever you face a design challenge.
The N+1 Problem Explained: How to Detect and Fix It in Go/Rails
Learn what the N+1 query problem is, why it degrades application performance, how to detect it with query logs, and how to fix it with eager loading in Go and Rails.
OS Notes
Explore OS fundamentals including swap memory, page cache, buffer cache, slab cache, dentry/inode structures, hard links, and symbolic links.
Laws of Software Development
Master Postel's Law, Parkinson's Law, and Pareto Principle in software development for better architectural and design decisions.