[Common Math 1 Part 1] What Does Common Math 1 Cover in the 2022 Curriculum?

Introduces where Common Math 1 fits in the 2022 curriculum, what this course covers, and how this series approaches it.

[Common Math 1 Part 2] Polynomial Operations and Arrays

Represents polynomials with coefficient arrays and explains why addition and subtraction laws feel natural in that representation.

[Common Math 1 Part 3] Bivariate Polynomials and Matrices

Extends single-variable ideas to two variables, representing polynomials as matrices and practicing array-based operations.

[NCS Numeracy Chapter 1] 7-Week Learning Roadmap

See how the seven-week NCS numeracy plan is sequenced for IT and software roles, what each week covers, and how to use the series.

[NCS Numeracy Chapter 01] Core Applied Math Archetypes

Group NCS Applied Math problems 1-68 into representative types, learn the setup for each type, and study the anchor solutions efficiently.

[NCS Numeracy Chapter 02] Practice Applied-Math Structures with Original Example Problems

Learn distance-time, mixtures, work rates, equations, and probability through original applied-math practice problems and step-by-step explanations.

[Calculus Series Part 1] Week 0: Limits of Sequences

Start the calculus series with sequence limits, then see how they lead into function limits and continuity.

[Calculus Series Part 2] Week 1: Limits of Exponential, Log, and Trig Functions

We unpack the meaning of the constant e, differentiate exponential and logarithmic functions, and derive key trigonometric limits through rich examples.

[Calculus Series Part 3] Week 2: Trig Derivatives and the Chain Rule

We derive trig derivatives from limits, connect them to the quotient rule, and practice the chain rule on layered examples.

[Introduction to Number Theory Series Part 1] What Is Number Theory? A 20-Part Roadmap

Get the big picture of number theory through its core questions and the full 20-part learning path of this series.

[Introduction to Number Theory Series Part 2] What Do Divisors and Multiples Show Us?

Learn how divisibility, divisors, multiples, quotients, and remainders form the first language of number theory.

[Introduction to Number Theory Series Part 3] Why Is the Division Algorithm the Starting Point of Number Theory?

See why the standard form a=bq+r with 0 ≤ r < |b| is the natural starting point for integer structure in number theory.

[Linear Algebra Series Part 1] A Linear Algebra Roadmap for Programmers

See how this 20-part linear algebra series is sequenced for programming, machine learning, graphics, and data work, and why it is ordered this way.

[Linear Algebra Series Part 2] Seeing Scalars and Vectors Through a Programmer's Lens

Understand the difference between scalars and vectors by connecting coordinates, feature vectors, and embeddings from a programming perspective.

[Linear Algebra Series Part 3] Vector Addition, Scalar Multiplication, and the Start of Linearity

Learn what vector addition and scalar multiplication mean through data combination, scaling, and the first idea of linearity.

[C Series 1] Why Study C Right Now?

Break down why C still matters from compilation, memory, and systems perspectives, and map the learning roadmap.

[C Series 2] Prepare C On macOS and Run Your First Compile

Verify Xcode Command Line Tools on macOS and walk through compiling and running your first C program with `clang`.

[C Series 3] Store Values with Variables and Primitive Types

Connect variable declarations, ints/floats/chars, `sizeof`, and format specifiers to build intuition about how C stores values in memory.

[FastAPI Series 1] Why FastAPI Is Worth Learning

Explains FastAPI's core advantages, the learning roadmap, and the mindset for this series.

[FastAPI Series 2] Getting Started: Install and Run Your First API

Covers uv-based setup, installing FastAPI, launching the dev server, and verifying the first GET endpoint.

[FastAPI Series 3] Separate Path and Query Parameters

Shows how to declare path vs. query parameters in FastAPI, validate them, and practice the flow in Swagger UI.

[JavaScript Series 1] Why Learn JavaScript Today?

Explains why JavaScript is at the heart of the web, how browsers use it, and why it matters for building modern interactive pages.

[JavaScript Series 2] Understanding Variables and Types

Walk through let vs. const plus strings, numbers, arrays, and objects using the browser console and Node.js.

[JavaScript Series 3] Reusing Code and Transforming Data with Functions and Array Methods

Learn the difference between function declarations and expressions, and see how `map`, `filter`, and `reduce` help you transform data clearly.

[Python Series 1] Why Start with Python?

Discover why Python's clear syntax, rich ecosystem, and automation strengths make it a great starting point for coding, and explore the learning roadmap ahead.

[Python Series 2] Set Up a Python Environment with uv on macOS

Walks through installing uv, creating a new project, setting up a virtual environment, and running your first Python file on a Mac.

[Python Series 3] Work with Data Using Variables and Types

Learn how to name variables, understand core Python data types, and write simple scripts that take input, process it, and give an output.

[Rust Series 1] Why Study Rust Now?

Explain why Rust matters through ownership, borrowing, and type safety, and map out the learning roadmap.

[Rust Series 2] Install Rust and Run Your First App

Install rustup and Cargo, then create, build, and run your first Rust project.

[Rust Series 3] Variables, Immutability, and Basic Data Types

Learn the rules behind let and mut, then practice scalar, tuple, and array types.

[Svelte Series 1] Why Svelte Clicks Quickly for Beginners

Summarizes why Svelte's low syntax overhead, intuitive reactivity, and component mindset make it a great starting point.

[Svelte Series 2] How to Read a Component File

Explains the script, markup, and style blocks that form a Svelte file and how state flows into the UI.

[Svelte Series 3] Managing Props and Event Forwarding

Covers parent-child data flow with props, custom event dispatch, and event forwarding in practical terms.

[Homebrew Series 1] What Is Homebrew?

Learn why many Mac developers use Homebrew by comparing it with manual installs.

[Homebrew Series 2] Installation and Terminal Setup

Install Homebrew, configure .zshrc, and verify the setup with real commands and expected output.

[Homebrew Series 3] Installing and Managing Packages

Install tree, wget, and htop, then practice listing, upgrading, removing, and cleaning up Homebrew packages.

[Git Series Part 1] What is Git?

Understand why Git solves the endless final_final.docx mess and why version control matters.

[Git Series Part 2] Installation and Basic Setup

Install Git with Homebrew, set your user info, and verify every setting with real commands.

[Git Series Part 3] Create a Repository and Make Your First Commit - init, add, commit

Initialize a Git repo, stage files, make the first commit, and read the history with hands-on commands.

[iTerm2 Series 1] What is iTerm2?

Compare the default macOS Terminal with iTerm2 and decide when iTerm2 becomes useful in a real workflow.

[iTerm2 Series 2] Installation and Basic Setup

Install iTerm2 with Homebrew and walk through fonts, themes, and the core preferences that make it ready for daily development.

[iTerm2 Series 3] Split panes, search, and shortcuts

Practice the iTerm2 features that speed up daily terminal work: split panes, search, autocomplete, profiles, and safer custom shortcuts.

[Tmux Series 1] What is Tmux?

Understand the problems Tmux solves and how sessions, windows, and panes help you organize terminal work.

[Tmux Series 2] Install Tmux and Launch Your First Session

Install Tmux with Homebrew, create your first session, and practice detaching, reattaching, and the essential shortcuts.

[Tmux Series 3] Practice Managing Sessions and Windows

Create multiple sessions, add windows, navigate between them, and keep work alive while switching contexts.

[Vim Series 1] Why Should You Learn Vim?

Experience situations GUI editors cannot solve and see exactly when Vim becomes indispensable.

[Vim Series 2] Install and Run Vim for the First Time

Install Vim with Homebrew, verify the setup, open a file, write text, and exit safely using real commands.

[Vim Series 3] Understand Modes and Essential Navigation

Learn why Vim uses modes, switch safely between them, and practice the core motions you need to move through a file without leaving the keyboard.

[OpenCode Field Notes Part 1] Why did work get harder even with more tools?

A personal account of fragmented setup, long-session context fatigue, and why I moved to a more sustainable CLI workflow.

[OpenCode Field Notes Part 2] 10-Minute Setup: Install, first run, and baseline config

A practical minimum setup to install OpenCode quickly and start with a repeatable workflow.

[OpenCode Field Notes Part 3] Provider strategy to reduce token/subscription interruptions

How I keep long coding sessions stable with primary/backup provider routing and account-level flexibility.

[Docker Series Part 1] What Docker Is and Why It Is Essential for Infrastructure

Learn the core concepts of Docker, how it creates consistent environments, and why it is a crucial tool for modern deployment and infrastructure.

[Docker Series Part 2] Connecting Images and Containers with Dockerfiles

Learn how Dockerfiles turn instructions into images, how those images become containers, and why that workflow locks environments into code.

[Docker Series Part 3] Ubuntu vs. Alpine - How to Pick a Base Image

Compare Ubuntu and Alpine images, run small labs, and build a checklist so you can choose the right base for practice and deployment.

[OPNsense Series Part 1] What OPNsense Is and Why It Pairs So Well with Proxmox

Learn what OPNsense handles as a firewall, router, and VPN gateway, and why it works so well alongside Proxmox in self-hosted infrastructure.

[OPNsense Series Part 2] Building the OPNsense VM on Proxmox and Drawing the WAN/LAN Line

Step-by-step guide to shape WAN/LAN bridges on Proxmox, pick virtual NICs, walk through the installer, and avoid wiring paths that bypass the firewall.

[OPNsense Series Part 3] Designing NAT, Port Forwarding, and Reverse Proxy Paths

Design outbound NAT, inbound port forwarding, and reverse proxy exposure on OPNsense so only the right services are public and policy gaps stay closed.

[Proxmox Series Part 1] What Proxmox VE Is and Why It Becomes a Starting Point for Homelab Infrastructure

Learn the core building blocks of Proxmox VE, including VMs, LXC, storage, and bridges, and why it fits single-server infrastructure so well.

[Proxmox Series Part 2] What to Inspect and How to Lay Out the Host Right After Installation

Clarify the roles of local-lvm and other storage, verify bridges, plan ISO/template storage, pick backup targets, and inspect mini PC hardware immediately after installing Proxmox.

[Proxmox Series Part 3] How to Split Workloads Between VMs and LXC

Use reverse proxy, monitoring, app server, database, Docker host, and Windows test box examples to build a repeatable decision framework for VM vs. LXC.

[DevCoop Build Log Part 1] AriPay and Occount Began Inside Our School Store

Trace how the student-run cooperative store’s pain points led to QR vouchers, student ID payments, and finally the Occount self-checkout system.

[MAICE Dev Log 1] Building a Teaching AI, not just an Answer Bot (Project Overview)

Data from 385 student questions showed why MAICE begins with clarification, and this post maps Bloom + Dewey principles into the multi-agent architecture that makes it work.

[MAICE Dev Log 2] How the agents collaborate (Multi-Agent System)

Why one giant prompt was not enough, and how Redis Streams + specialized agents improved reliability and educational behavior.

[MAICE Dev Log 3] SvelteKit chatbot interface for real-time math rendering

How we improved math-chat UX with MathLive input, OCR support, and streaming-safe LaTeX rendering.