Posts
English technical posts on the Astro branch. 한국어 글 목록 →
-
What is beam search? How it differs from greedy decoding, and why chatbots use sampling more
Beam search keeps several candidates per step and picks by cumulative score, while greedy picks one token. This post covers why chatbots prefer sampling and when beam search fits.
-
const int* vs int* const: how do you read where const goes on a C++ pointer?
`const int*` locks the pointed-to value, whereas `int* const` locks the pointer itself. The dividing line is `*`: `const` to the left of `*` makes the value const, and `const` to the right of `*` makes the pointer const, which is why `const int*` and `int const*` are the same type. Reading a declaration from the variable name leftward keeps the meaning clear. Writing `const T*` or `const T&` on function parameters lets the compiler verify the promise that the function will not modify the argument.
-
How do you use Ollama? From installation to your first local LLM run and API call
Learning how to use Ollama on Linux starts with installing the binary, running the local server (ollama serve), registering a language model, and calling it from the CLI (ollama run) or the local REST API on 127.0.0.1:11434 with curl.
-
Are blocking/non-blocking and sync/async the same thing? Wait queues, O_NONBLOCK, epoll and io_uring
The difference between blocking vs non-blocking and synchronous vs asynchronous I/O comes down to two separate questions: whether a call waits when I/O cannot proceed yet, and whether the call itself performs the I/O and returns the result or submits a request whose completion is collected later. Based on the Linux manual pages (`pipe(7)`, `read(2)`, `epoll(7)`, `io_uring(7)`), official Linux kernel documentation, and four C programs run in this post's environment (x86-64 Linux, gcc 14.2, liburing 2.9, strace 6.13), this post compares how each model behaves on a real pipe.
-
What is the difference between I2C, SMBus and I3C?
Understanding the difference between I2C, SMBus and I3C comes down to what electrical, timing, and command rules SMBus tightens on top of the baseline two-wire I2C bus, and how MIPI I3C redesigns addressing, interrupts, and line driving while remaining backward compatible with legacy I2C targets. Based on the SMBus Specification 3.3.1, the Linux kernel documentation, and the MIPI I3C specification resources, this post compares the three protocols and walks through a pure Python 3.13 computation of the SMBus PEC (CRC-8) byte.
-
What is the difference between open-drain and push-pull? Why pull-up and pull-down resistors are needed
The core difference between open-drain and push-pull GPIO outputs lies in whether the output stage actively drives the line to both high (1) and low (0) logic levels, or actively drives only one level and releases the line to a high-impedance (Hi-Z) state for the other. Based on the Linux kernel GPIO driver and consumer interface documentation along with an illustrative Python logic-level model, this post explains how both output stages work and why pull-up or pull-down resistors are required.
-
How does a user program call the kernel? The svc/syscall, ioctl and copy_from_user flow
User programs normally call glibc wrapper functions such as `write()` and `read()`—or the generic `syscall(2)` library function—which place the system call number and arguments into registers and execute the architecture's transition instruction (`svc #0` on arm64, `syscall` on x86-64). When plain byte-stream reads and writes are not enough, `ioctl()` manipulates underlying device parameters of special files using an open file descriptor, a 32-bit operation code (encoded with `_IO`, `_IOR`, `_IOW`, or `_IOWR`), and a memory pointer. Inside the kernel, VFS dispatches the call through `struct file_operations` callbacks (`read`, `write`, `unlocked_ioctl`, `compat_ioctl`), and kernel code copies user-space memory safely with `copy_from_user()` and `copy_to_user()` instead of dereferencing user pointers directly.
-
CNN vs LLM: why a small dedicated model beats a large language model at image classification
Understanding the difference between a CNN and an LLM clarifies when to use a dedicated classifier versus a general-purpose generative model for image classification. This post compares how a CNN and a multimodal LLM approach skin lesion classification in terms of architecture and training, reports a small dermatologist-run experiment, and outlines limits, FAQs, and when to combine both model types.
-
What is C++26 std::breakpoint? Using the <debugging> header to stop in the debugger from code
std::breakpoint is a C++26 standard function that asks from within code to pause execution and hand control to the debugger. Previously, developers relied on compiler- or OS-specific facilities such as __debugbreak, __builtin_debugtrap, or asm("int3"), which are now standardized under the <debugging> header. Use std::breakpoint_if_debugging() to stop only when a debugger is attached, and std::is_debugger_present() to check whether the program is running under a debugger. Exact behavior is implementation-defined, and GCC 14.2 in our environment did not include this header yet.
-
What is positional encoding? How Transformers know word order and how RoPE differs
Positional encoding is the mechanism that injects token position information into a Transformer so the model can tell word order apart. This post explains why Transformers need explicit order information, how sinusoidal positional encoding and learned positional embeddings work, and how Rotary Position Embedding (RoPE) differs by rotating Query and Key vectors.
-
What is SIMD? How one instruction processes multiple data and how to check C++ compiler auto-vectorization
Following a Hacker News discussion on accelerating computer vision (FAST) with 128-bit SIMD on the ESP32-S3, this post explains SIMD (Single Instruction, Multiple Data) and how to check C++ compiler auto-vectorization with g++ on a PC using `-O3 -fopt-info-vec-optimized`.
-
What is a stack overflow? Finding and preventing MCU stack overflows for embedded interviews
A stack overflow happens when the stack used by function calls, local variables, and interrupts exceeds its allocated size and overwrites adjacent memory. On an MCU without an MMU, this rarely triggers an immediate clean fault; instead, neighbouring data such as .bss or the heap is silently corrupted, leading to hard-to-trace malfunctions or resets. To find it, inspect per-function frame sizes at compile time with -fstack-usage and -Wstack-usage, and check peak usage at run time with stack painting or FreeRTOS overflow checking and high water mark APIs. To prevent it, move large buffers off the stack, eliminate recursion, and size stacks from measured usage plus a margin.
-
Batch normalization vs layer normalization: why do transformers use LayerNorm?
Layer normalization and batch normalization stabilize deep network training by normalizing activations across layers. This post explains how they differ in which axis they aggregate mean and variance, how that affects mini-batch and inference behavior, and why transformers standardize on LayerNorm.
-
What is an optimizer? SGD vs momentum vs Adam, and which to pick first
An optimizer applies backpropagation gradients to update neural network weights. This post compares SGD, momentum, Adam, and AdamW, how they move on a loss surface, and common starting choices.
-
static_cast vs reinterpret_cast: how do you choose a C++ cast?
Use `static_cast` for conversions the compiler understands—numeric value conversions, scoped `enum` to integer, restoring `void*` back to its original object pointer type, and pointer or reference conversions within an inheritance hierarchy. Use `reinterpret_cast` for low-level conversions that reinterpret the underlying bits or change how a pointer is viewed—converting between a pointer and `std::uintptr_t`, or between unrelated pointer types. As verified by the compiler errors below, `static_cast` cannot convert `int*` to `double*`, while `reinterpret_cast` cannot convert a `double` value to `int` and cannot remove `const`. For runtime polymorphic type checking use `dynamic_cast`, and to cast away `const` use `const_cast`.
-
What is cross-entropy loss? Why classification models use it instead of MSE
Cross-entropy loss measures how much probability a classification model assigns to the true class. This post covers -log(p), the softmax pipeline, why it beats MSE for classification, and its role in LLM pretraining.
-
What is an ESP32 emulator? Running firmware on a PC or in the browser without a board
An ESP32 emulator imitates the CPU and selected peripherals in software so you can run compiled firmware on a PC or in a browser without a physical board. This post summarizes concepts, use cases, differences from real hardware, and tools such as the QEMU fork, esp32sim, and Wokwi based on official documentation and community discussions.
-
What are common MCTP/PLDM interview questions and model answers? 19 Qs on packets, EIDs, Instance IDs, sensors, firmware update and debugging
Most MCTP/PLDM questions fall into five groups: MCTP packets and addressing (EIDs and tags), PLDM common rules (TID and Instance ID), monitoring (sensors, thresholds, and events), firmware update (Type 5 sequence), and the layer-by-layer order for debugging a missing response. Citing the underlying specification numbers (DSP0236, DSP0240, DSP0248, DSP0267) makes each answer much stronger.
-
How are MCTP and PLDM handled on Linux? AF_MCTP sockets, mctp, mctpd, libpldm and pldmd
Based on the Linux kernel MCTP documentation and the CodeConstruct and OpenBMC repositories, this post explains AF_MCTP sockets and sockaddr_mctp, the mctp and mctpd tools, and libpldm and pldmd. It includes checking Errno 97 on a kernel without MCTP, building user-space tools, and encoding a PLDM Base GetPLDMTypes request into bytes.
-
What are MCTP and PLDM? Server device management and how MCTP packets, EIDs and bindings work
MCTP and PLDM are DMTF PMCI standards used inside a server board so that a BMC and on-board devices can exchange management messages. Based on DSP0236 MCTP Base Specification 1.4.0 and transport bindings, this post explains server device management structure, the MCTP transport header, EIDs, message tags, bindings, and the bus owner.
-
What are PLDM types? Base, monitoring (PDRs and sensors), firmware update and RDE
PLDM is a DMTF standard that uses the PLDM type field in its message header to group base discovery, platform monitoring (PDRs and sensors), firmware update, and RDE. Based on DSP0240 PLDM Base Specification 1.2.1 and companion type specifications, this post summarizes the common header and the roles of Types 0, 2, 5, and 6 plus the firmware update sequence.
-
What is speculative decoding? Why a small draft model makes LLM answers faster
Speculative decoding proposes several next tokens with a small draft model and verifies them in one forward pass with the large target model. This post covers why total compute can rise while latency drops, when speedups shrink, and how output quality stays aligned with the large model.
-
What is the C++ "undefined reference" error? Fixing the link error when there is a declaration but no definition
The C++ undefined reference error occurs at link time when compilation succeeds but the linker cannot find a matching definition for a declared symbol. Four cases reproduced with g++ 14.2 and nm output show common causes and fixes.
-
What are std::future and std::promise? Getting a result back from a C++ thread, and how std::async differs
std::future is the standard C++ handle for receiving a one-shot value or exception computed on another thread. This post explains std::promise, std::async, broken_promise, and wait_for with programs verified on g++ 14.2.
-
What is a learning rate? How to adjust it when the loss jumps around or won't go down
The learning rate is the hyperparameter that sets how far weights move along the gradient in one gradient-descent step. This post covers update rules, loss behavior when the rate is too large or small, tuning with short experiments, and learning rate schedulers with warmup.
-
What is a ring buffer (circular buffer)? Implementing a UART receive buffer in an embedded interview
A ring buffer (circular buffer) is a classic data structure in embedded interviews when discussing how to implement a UART receive buffer. This post explains head and tail movement, full vs empty detection, and ISR caveats using the Linux kernel docs and a C example verified with gcc 14.2.
-
What is RLHF? Aligning LLM outputs with reward models, PPO, and DPO
RLHF trains a reward model on human comparison data, then tunes the language model with PPO reinforcement learning. This post covers reward model training, the KL penalty, reward hacking, and how DPO differs.
-
What is an activation function? ReLU vs GELU vs sigmoid, and how to choose
Activation functions add nonlinearity between linear layers so deep networks can learn patterns beyond a single straight decision boundary. This post covers why they are needed, how sigmoid, ReLU, and GELU differ in shape, their tie to vanishing gradients, and how to pick activations for hidden versus output layers.
-
What is formal verification? How it differs from testing and fuzzing, and what changes when an LLM writes the proofs
Formal verification states rules mathematically and uses a proof checker to confirm they hold across all inputs in scope—unlike tests or fuzzing—yet "verified" does not mean bug-free if the spec or machine model diverges from reality. This post covers what LLM-written proofs change, and how verification relates to Rocq, ASan, and C++26 Contracts.
-
What is knowledge distillation? Training a small model from a big one, and how it differs from quantization
Knowledge distillation trains a smaller student model to match the class probability distributions (soft targets) produced by a large teacher model. This post covers why soft targets beat hard labels alone, temperature, how distillation differs from quantization, and when to use it.
-
SK hynix Q3 2026 Earnings Explained: Record ₩104.6T Revenue, HBM4 Ramp and Long-Term Supply Deals
SK hynix Q3 2026 results as reported (KRW 104.6T revenue, KRW 83.3T operating profit), why net profit fell, what the HBM4 ramp means technically, and how long-term supply agreements change memory supply. No stock-price talk.
-
What does the post-task Q&A in an AI skills assessment check, and how do you prepare?
The post-task Q&A in an AI skills assessment asks you to explain your deliverable and decision rationale after submission, then cross-checks your answers against the actual implementation. It mainly probes cognition—whether you can explain how your result works and where it can fail. Recording the why as you work and practicing answers in weakness, risk, and next-verification order are among five habits that help you prepare.
-
What is backpropagation? How a neural network uses gradients to fix its weights
Backpropagation passes the loss from the output layer back toward the input, using the chain rule to compute each weight's gradient in a multi-layer network. This post covers the four-step training loop, what gradients mean, a chain-rule walkthrough, and how backpropagation differs from gradient descent.
-
What is endianness? Telling big-endian from little-endian in an embedded interview
Endianness is the order in which the bytes of a multi-byte value are placed in memory. Little-endian stores the LSB at the lowest address and big-endian stores the MSB there; use htonl to convert to network byte order (big-endian) before sending on the network.
-
What is the C++ "multiple definition" error? Why a function defined in a header needs inline
The C++ multiple definition error is a classic link-time failure when a non-inline function body lives in a header included from multiple .cpp files. Using code and linker output reproduced with g++ (Debian 14.2.0-19) 14.2.0 on 2026-10-25 (KST), this post explains One Definition Rule (ODR) violations and fixes with inline, a declaration/definition split, or static/internal linkage.
-
What are the three debts of AI coding agents? Technical, intent and cognitive debt, and habits that reduce them
Delegating work to an AI coding agent produces code quickly, but alongside technical debt it can accumulate intent debt—where what is being built and why is never recorded—and cognitive debt, where the team loses understanding of the system. Habits such as pulling out requirements one by one, scoping each prompt, cross-checking numbered requirements against evidence, recording the why, and delegating in small chunks reduce these debts.
-
What is C++ lambda capture? The difference between [=] and [&], and when dangling references appear
C++ lambda capture is the syntax that brings outer-scope variables into a lambda by copy ([=]) or by reference ([&]). When a lambda outlives the variable—returned, stored, or passed to another thread—reference capture dangles. This post covers g++ 14.2 examples, catching stack-use-after-return with AddressSanitizer, and [*this] and smart-pointer capture rules.
-
.data vs .bss: where global variables live in memory, for embedded interviews
The .data vs .bss difference comes down to initial values. .data holds globals and statics with a non-zero initializer stored in the file (flash on embedded targets); .bss holds zero or uninitialized globals with only size recorded in the file and zero-filled at startup.
-
What is an LLM confidence score? Why you should not just ask the model how sure it is, and what calibration means
Developers often want an LLM confidence score when building support agents, but a number from simply asking the model how sure it is cannot be trusted at face value. This post explains why and what calibration means.
-
What are AI Native and AI literacy? The difference and how to build them
AI literacy is defined in public documents such as the EU AI Act as the ability to understand how AI works, judge its outputs critically, and use it responsibly. AI Native has no standard definition and commonly describes working or designing systems with AI as the default premise. This post explains the difference, competence stages, work examples, and how to build both, based on public sources.
-
What is latent reasoning? How it differs from CoT when an LLM thinks without writing text
Latent reasoning feeds the last-layer hidden state back as the next input instead of writing intermediate thoughts as tokens. CoT leaves readable text but costs more tokens; latent reasoning can use fewer tokens but is harder to audit. This post covers tool calling and inspectability based on the Hybrid Reasoning Agents paper.
-
What is overfitting? How to fix it when training loss falls but validation loss rises
Overfitting means the model fits the training data so closely that it fails on new data. When validation loss rises while training loss keeps falling, suspect overfitting. This post covers reading loss curves, diagnosis, and fixes in order: early stopping, more data, regularization, dropout, and smaller models.
-
What is a virtual destructor in C++? Why delete through a base pointer needs virtual
A virtual destructor ensures deleting through a base pointer runs the destructor of the object’s real type. Without virtual on the base destructor, the standard calls that undefined behavior. This post covers g++ 14.2 observations, smart pointers, and interview answers.
-
Buildroot vs Yocto: what's the difference when choosing an embedded Linux image build tool?
Buildroot is a simple tool that builds the root filesystem and image in one pass from menuconfig/defconfig. Yocto is a large framework that manages packages and distributions with layers, recipes and bitbake. For a small product or a fast start, pick Buildroot. For multiple products, long-term maintenance or package management, pick Yocto.
-
What are C++26 Contracts? Checking function conditions with pre, post and contract_assert
C++26 Contracts let you attach pre and post to a function declaration and check conditions in the body with contract_assert. This post contrasts assert, explains evaluation semantics, and documents GCC 14.2 lack of support versus GCC 16 in the cppreference table, with real g++ output.
-
What is the Rust borrow checker? How it differs from C++ ownership and lifetimes
The Rust borrow checker enforces ownership, references, and lifetimes at compile time. This post walks through E0382, E0502, and E0597 with real rustc and g++ output, and contrasts the model with C++ RAII and AddressSanitizer.
-
What is an LLM inference framework? How serving engines like vLLM and llama.cpp differ when you choose one
An LLM inference framework is the runtime that loads trained weights, accepts requests, and produces tokens. This post compares server-style engines such as vLLM with local-style ones such as llama.cpp, how to choose, and why model makers ship their own engines.
-
What is a watchdog timer? How it recovers a hung system, explained for embedded interviews
A hardware watchdog resets the system when software stops sending kicks in time. This post covers how it works, where to place kicks, the Linux /dev/watchdog API, and common interview questions, based on the kernel watchdog docs.
-
What is the "expected unqualified-id before numeric constant" error? How to fix C++ macro name clashes
The expected unqualified-id before numeric constant error appears when a macro such as #define MAX_SIZE 100 expands where a name belongs and leaves a number behind. This post explains the cause and fixes—renaming, constexpr, or #undef—using code and real g++ 14.2.0 compiler output reproduced on 2026-10-21 (KST).
-
What is Grok 4.8? What a 2.5T-parameter model and a C++ training stack mean
Official public information on Grok 4.8 comes down to Elon Musk's posts on X. This post explains a rough memory estimate for 2.5T parameters, what the RL stage generally means, and common reasons teams choose a C++ training stack.
-
What is the difference between an NPU and a GPU? A simple comparison by structure, use case, and power
The NPU vs GPU gap comes down to design focus: a GPU is a general-purpose parallel processor, while an NPU is a dedicated accelerator built around multiply-accumulate (MAC) ops for neural networks. This post compares structure, training vs inference, and power and use cases for beginners and embedded developers.
-
What is valgrind? How it differs from ASan when hunting C/C++ memory leaks
valgrind (Memcheck) runs your existing binary without recompilation to catch leaks, uninitialised reads, invalid accesses, and bad frees, but slows execution by roughly 20–30×. When you can recompile, start with AddressSanitizer (~2× slowdown); reach for valgrind when you cannot recompile or need --track-origins=yes and a full leak summary in one run.
-
What is C++ RAII? When to let destructors release resources automatically
C++ RAII (Resource Acquisition Is Initialization, also called SBRM) binds resources that must be acquired before use—heap memory, threads, sockets, files, mutex locks—to object lifetime. Constructors acquire (or throw); destructors release without throwing, in reverse order of acquisition on every exit path. This guide covers lock_guard, smart pointers, custom guards, embedded use, and interview FAQs.
-
What is mechanistic interpretability? How it differs from polysemanticity, where one neuron holds many concepts
Mechanistic interpretability reverse-engineers a model's internal neurons, features, and circuits—unlike XAI attribution that only highlights which inputs mattered. This post explains polysemanticity, superposition, sparse autoencoders (SAEs), and the ongoing debate around whether neural networks are "clean."
-
AI basics and AI task-solving: a final review the day before
A same-day review: one-page concept summary, 10 O/X pitfalls, document-and-data AI task workflow, and a practice mistake checklist for a 30–40 minute morning pass.
-
SK hynix AI Hackathon first-round qualifier review (short)
Brief thoughts after the SK hynix AI Hackathon first-round qualifier—no problem spoilers. Multiple-choice section, AI-assisted tasks, and links to prep posts.
-
AI Basics Practice Quiz Part 2: 28 Multiple-Choice Questions — Can You Answer the Same Concepts From a Different Angle?
Part 2 of the AI basics practice quiz: 28 four-option questions in 10 groups that revisit the same concepts from new angles, with answers and explanations in toggles below each question.
-
AI Basics Summary and 28 Practice Questions: How Do You Tell Confusing Concepts Apart?
Based on this blog's AI study posts, this guide summarizes 15 topics with key ideas and easy-to-mix-up comparisons, plus 28 self-made multiple-choice questions with answers and explanations.
-
How I approach document- and data-based AI tasks (the one-turn prompt formula)
A practical playbook for LLM tasks over policy PDFs, master tables, and logs: verbatim questions, one-turn prompts, trimmed output, verification on a different path, and spot-checking boundary rows.
-
What Is SDR (Software-Defined Radio)? Steps to Receive 433 MHz Sensor Signals with an RTL-SDR
SDR demodulates and decodes IQ samples from the antenna, tuner, and ADC in PC software. This guide covers unloading the DVB-T driver, verifying the dongle with rtl_test, and decoding 433.92 MHz sensors with rtl_433 using captured terminal output and public sample files.
-
What is WSL? Why AI Agents Run More Reliably Inside WSL on Windows
WSL 2 runs a real Linux kernel in a lightweight VM on Windows. This post covers why agent tools expect Bash, POSIX paths, execute bits, and case sensitivity; where to keep project files; install commands; and fact-checking recent WSL 3.0 claims—on a WSL 2 basis.
-
What Is C++ explicit? When to Block Implicit Constructor Conversions
C++ explicit stops constructors, conversion functions (since C++11), and deduction guides (since C++17) from taking part in implicit conversions and copy-initialization. A constructor without explicit is a converting constructor, so a call such as f(5) can turn a raw value into an object. Prefer explicit on single-argument constructors, and leave it off only when the conversion is natural, as with std::string s = "abc";.
-
What Is Cross-Compiling? Building with ARM gcc and Running It in QEMU, Step by Step
Cross-compiling builds ARM aarch64 binaries on an x86_64 host. This guide walks through installing aarch64-linux-gnu-gcc on Debian, building hello.c, and running the ELF with qemu-aarch64 -L against the target sysroot, with captured terminal output.
-
What Is IoT Security? Blocking Authentication Bypass and Internet Exposure on Embedded Devices
Embedded IoT security is the practice of designing defenses for hardware that directly operates physical equipment and runs unattended in the field for long periods. It means unique initial passwords on each device, management interfaces kept off the public internet, and a split between read (sensor) and write (actuator) from the architecture stage. The OWASP IoT Top 10 also lists weak or default passwords, insecure network services, and insecure default settings among its main categories. Engineering defaults should therefore include a mandatory password change on first boot, isolation behind a VPN or firewall, one-way telemetry, and cryptographically signed firmware updates.
-
Want ChatGPT Plus or SuperGrok for less? Official pricing and why VPN signups are hard
If you want ChatGPT Plus for less, or you want SuperGrok to stay affordable, check the latest rates on each official page first. Prices vary by region and tax. A VPN signup meant to lower the bill can bring declined payments, account limits, terms-of-service problems, and little chance of a refund or support, so it is hard to recommend.
-
How should you prepare for an AI exam? What I learned studying, plus an exam setup checklist
Preparing thoroughly for an online AI exam requires two essential pillars: a systematic study loop and an advance check of your online proctored exam setup. First, explain concepts in simple words, quiz yourself, write your own answer before reading the explanation, and then compare. When delegating tasks to AI, establish a solid 4-step routine: common material, conditions, verification, and format. Second, install the Monito app—accessed via your invited exam link—grant camera and microphone permissions, and prepare a phone stand, Do Not Disturb mode, and chargers. Third, never cheat under any circumstances, and always follow the official guidelines of the exam you are taking.
-
What Is Speech Recognition (STT)? How Speech Becomes Text, and How On-Device STT Differs
Speech-to-text (STT) converts speech into text by sampling continuous sound waves at 16,000 numbers per second (16 kHz), transforming them into a 2D mel spectrogram aligned with human hearing, and using a Transformer encoder-decoder to predict text tokens sequentially. While cloud STT offloads processing to remote servers, on-device STT runs optimized, smaller models locally on the device—eliminating network latency, enabling offline operation, and keeping voice data private, at the cost of tighter compute and model size constraints.
-
What Is a C++ Compiler Front End? How GCC, Clang, MSVC, and EDG Differ
A C++ compiler front end processes source code through lexing, parsing, and semantic analysis (including template instantiation and `constexpr` evaluation) to produce a hardware-independent intermediate representation (IR or IL). In contrast, the back end takes this intermediate representation and translates it into machine code for the target CPU. This architectural separation underpins major compilers like GCC, Clang, MSVC, and EDG. EDG is particularly distinctive because its front end itself has long been its primary product. On September 30, 2026, EDG's C++ front end source code was made publicly available under The C++ Alliance as its nonprofit home, licensed under the Apache License v2.0 with LLVM Exceptions.
-
Is Gemini 4 Argon Worth Using as a Cursor Coding Agent? CursorBench Scores, Pricing, and Signup Hurdles
Gemini 4 Argon ranks 6th on CursorBench 4.0 (as of publish date) with a score of 52.9% on High settings at $4.57 per task. It is officially listed in Cursor's model catalog and accessible through the "Other Models" pool included with the Cursor Pro plan ($20/mo). Using Argon in Google Antigravity, however, requires a Google AI Ultra subscription, and minor score differences across benchmark tiers may not reflect meaningful real-world gaps. Rather than choosing strictly by model name, evaluate benchmark scores, task costs, and account requirements together.
-
How to Install Yocto BitBake and Boot core-image-minimal in QEMU
On Yocto 6.0 "Wrynose" LTS (supported until 2030), start a BitBake build with the bitbake-setup tool and configuration fragments. Install the host packages and the en_US.UTF-8 locale, run bitbake-setup init --non-interactive, source init-build-env, enable the root-login fragment that ships disabled, and run bitbake core-image-minimal. Then boot the image with runqemu qemux86-64 nographic and log in as root.
-
Prompt, Context, Harness, and Graph Engineering: What Is the Difference?
Prompt engineering is writing and organizing the instructions you give an LLM; context engineering is curating and managing everything the model sees, including tool definitions, retrieved data, history and memory beyond the instructions (Anthropic's definition). Harness engineering is designing the runtime around the model (tools, loops, verification, permissions, state), and graph engineering is structuring work as a graph of nodes, edges and shared state, LangGraph-style, to fix the flow. The last two are recent terms without a standard definition, so this post summarizes how they're actually used, with sources.
-
How a Solo Founder Organizes an AI Team and Builds a Product in Stages
The cases published by people building products alone with AI share a structure. The human sits at the top and keeps direction, product decisions, approval and customer relationships; below that, a coordinator agent splits the work and hands it to role agents (product, build, verification, marketing and support). Official docs from Anthropic, OpenAI and CrewAI all advise starting with one agent and adding roles and hierarchy only when needed. The solo-founder cases, however, are all self-reported, so independently verified evidence is still thin.
-
BLE GATT from Scratch: Structure, bluetoothctl Practice, and a Reliable PASS Verdict
In BLE, a Peripheral advertises and a Central scans and connects. The rules for finding and connecting are GAP; the rules for exchanging data once connected are GATT, whose data is organized as a service → characteristic → descriptor tree identified by UUIDs. On Linux, BlueZ `bluetoothctl` reads a value with `connect` → `menu gatt` → `select-attribute` → `read`. When you automate the test, don't treat `ServicesResolved: yes` as a PASS; only pass when a value appears on the line after `Attempting to read …`.
-
What Is an Embedding? How Turning Words into Vectors Lets Us Compare Meaning
An embedding turns data such as words into numeric vectors that carry meaning. Once words are vectors, you can calculate how similar their meanings are from distance or angle, and the standard way to compare by angle is cosine similarity.
-
How to Find Crash Causes with gdb in Embedded Linux: Core Dump and gdbserver in Practice
When an embedded Linux process crashes with a Segmentation fault (SIGSEGV), you can inspect the post-mortem state by opening the core dump in gdb alongside the matching symbol-bearing binary and running `bt` to find where it died, or debug it live by running `gdbserver` on the board and connecting from the host PC via `target remote board-ip:port`. Because gdbserver has no built-in security of its own, it must only ever be used on an isolated private network.
-
I2C vs SPI vs UART: How to Compare Them in an Embedded Interview
An interview comparison of I2C, SPI, and UART starts with wire count and whether the bus is synchronous or asynchronous. I2C is 2-wire synchronous, SPI is 4-wire synchronous, and UART is 2-wire asynchronous; then cover device selection, speed, and a typical use for each.
-
What Is C++ Integral Promotion? Why ~true Evaluates to true
Before any arithmetic or bitwise operation runs, integer types smaller than `int` (such as `bool`, `char`, and `short`) are automatically converted into a value-preserving `int` (or `unsigned int`). This is known as integral promotion. As a result, `true` promotes to `int 1`, and flipping its bits with `~` yields `-2` under two's-complement representation; converting `-2` back to `bool` evaluates to `true` because it is nonzero. To negate a boolean, always use `!` instead of `~`.
-
std::vector Reallocation and Iterator Invalidation: Why Crashes Happen After push_back
When the number of elements exceeds its `capacity()`, `std::vector` performs a reallocation: it allocates a new, larger block of memory, moves the existing elements into it, and frees the old block. Once that happens, every iterator, pointer, and reference that pointed into the old buffer becomes dangling, and using it afterward is undefined behavior (UB). If you know the number of elements in advance, calling `reserve()` to pre-allocate capacity is the standard way to avoid reallocation entirely.
-
How to Use YouTube Premium for Less? Official Prices, Why VPN Signups Get Blocked, and an Alternative
When you look for a cheaper way to use YouTube Premium, the first things to check are the official price and the risks. The current official rate is ₩14,900/month for an individual plan (as of publication date), and Premium Lite is ₩8,500/month (as of publication date). Signing up from another country through a VPN can lead to a declined payment or a canceled subscription, so if you want to lower the monthly cost, it is worth also looking at a practical alternative such as a shared subscription.
-
Day5–7: AI Limitations, Embedding and RAG Architecture, AI Agents and Tool Calling
Hallucination happens because an LLM predicts the plausible next token by probability instead of looking up facts. RAG is the whole method of finding relevant documents and putting them into Context, and an Agent is the loop where the LLM picks a tool, looks at the result, and decides the next action itself.
-
What Is C++ Insights? How to See the Code Your Compiler Hides (Lambdas, Range-for)
C++ Insights is a Clang-based source-to-source transformation tool that re-expands what the compiler actually does behind your source code back into plain C++. It lets you see which class and `operator()` a lambda turns into, how a range-for loop is expanded into a `begin`/`end` iterator loop, and which constructor gets implicitly called when a struct is copy-initialized — all in the same C++ syntax, not assembly.
-
What Is MoE (Mixture of Experts)? How It Differs from Dense Models and Why It Needs So Much Memory
MoE keeps several expert FFNs instead of one, and a router runs only a few of them (top-k) for each token. Per-token compute stays small, but every expert still has to sit in memory, so the memory footprint is large.
-
Programmers AI Assessment Practice Review: Why Do I Get Stuck Using AI the Way I Code?
I tried the Programmers AI Assessment practice set and got a little over half right. I'd thought it would be easy, and it hit me that at this rate I'd fail. The problem was asking AI from the start, the way I do when coding. Now I'm preparing with one rule: "AI is the hands; I'm the head."
-
What Are Tokens and Context Windows? How LLMs Count Text and Why Length Limits Exist
An LLM token is the basic unit a model uses to process text, and the context window is the cap on how many tokens one request can hold. Counts depend on the encoding and language, and hidden reasoning tokens take space inside that limit too.
-
Copy Constructor vs Move Constructor in C++: Which One Is Called, and When?
The copy constructor vs move constructor question comes down to what gets handed over. A copy constructor (T(const T&)) leaves the source untouched and duplicates everything, while a move constructor (T(T&&)) takes over the source's resources (a heap pointer, for example) and leaves the source in a valid-but-unspecified state. Named lvalues pick the copy constructor; temporaries and objects cast with std::move pick the move constructor — and a common trap is that declaring a destructor alone suppresses the compiler-generated move constructor.
-
std::map vs std::unordered_map: What's the Difference, and When Do You Use Which?
The map vs unordered_map difference comes down to internal structure: std::map is a tree that keeps keys sorted, guaranteeing O(log n) for lookup, insertion, and deletion, while std::unordered_map uses hash buckets for average O(1) but no ordering. Choose map when you need sorting or range search, and unordered_map when you mostly do single-key lookups and order doesn't matter.
-
Pretraining vs Fine-Tuning vs RLHF: What Stages Build an LLM?
Pretraining, fine-tuning, and RLHF are the stages that typically build an LLM. Pretraining uses next-token prediction to make a Base model, supervised fine-tuning uses instruction–response examples to make an instruction-following model, and RLHF folds in human preferences to make a conversational model.
-
What Is the SK hynix AI Hackathon 2026? Passing the Document Round and My Resolve for Round 1
The SK hynix AI Hackathon 2026 is an individual contest where you prove your AI skills with results, regardless of education, major or years of experience. I passed the document round with a portfolio about making embedded verification unattended together with AI agents, and I'm now preparing for Round 1 in October.
-
What Are Temperature and Top-p? Why LLM Answers Change Every Time
Temperature and top-p control how an LLM picks the next token. Temperature shapes the probability distribution, while top-p and top-k set the candidate range, so the same question can get a different answer when sampling is used.
-
What Is DMA? How It Differs from CPU Copy and How to Answer in Embedded/Firmware Interviews
DMA lets a DMA controller move data between a peripheral and memory, so the CPU only handles setup and completion. In an interview, explain how that differs from a CPU copy and cover cache coherency as well.
-
What Is Quantization? FP16 vs INT8 vs INT4 and Why LLM Memory Shrinks
LLM quantization stores weights with fewer bits, which cuts memory use and how much data has to be read. This note compares FP16, INT8, and INT4, and why that saving matters when Decode is memory-bound.
-
When Does the Cost Burden Flip from an API Plan to a Local AI Box?
An API subscription is enough when repeated work stays at human pace, the data may leave the building, and a limit only means wait or switch model. A local box is the candidate when residency, round-trip latency, or the same quota keeps stopping the job. Cut retries and oversized context before you add hardware.
-
Micron HBM4 Custom (NVHBM): How Does It Differ From JEDEC in the Supply Chain?
How JEDEC-standard HBM4 stacks differ from NVIDIA’s custom NVHBM (base die, controller, PHY) in the supply chain—using Micron IR and NVIDIA’s developer blog. No mass-production invention, share figures, or stock tips.
-
Cross-compile sysroot missing headers: how to fill them
Separate include-path failure signals with --sysroot and PKG_CONFIG_SYSROOT_DIR, then copy headers, libs, and .pc files from a board/rootfs image into the sysroot. Grounded in GCC and pkg-config docs. No affiliate.
-
systemd path units: start a service when a file appears
Pair .path + .service with PathExists/PathChanged for oneshot activation. Short timer/OnCalendar contrast only. Grounded in man systemd.path and journal debug. No affiliate.
-
Agent Browser Automation: Only After MCP Fails? Branch Criteria
Connector-first MCP vs browser fallback: why MCP first, signals to switch to the browser, and login/2FA as human handoff only. No pricing or invented UI paths.
-
When Should You Switch Between Claude Sonnet 5.5 and Opus 5.5 for Coding?
Everyday coding stays on Sonnet 5.5; open-ended judgment and long runs stay on Opus 5.5. The migration note is thinking and between_tools. Prices and benchmark figures are left out.
-
GitHub Copilot Chat vs Cursor Agent: How to Split Roles
How to split Copilot Chat (inline / IDE assist) and Cursor Agent (multi-file agent loops) in one repo. No pricing, review scores, or invented UI.
-
Device Tree Overlay Not Applying: Debug Order
Debug order when a DT overlay does not apply: dtc -@ / symbols, config.txt dtoverlay path, /proc/device-tree. Grounded in kernel and Raspberry Pi docs. No board anecdotes or prices.
-
When Should You Choose a ~3 TOPS NPU SoM for Embedded Vision on Debian?
Treat 3 TOPS as a vendor spec label. This is which camera workloads fit, what to check first in a Debian BSP, and what separates a SoM from an SBC.
-
How Does the Hexagon NPU Look Upstream in the Snapdragon X2 Linux Preview?
Who the Snapdragon X2 Linux preview is for on the kernel and distro side, how Hexagon is reached through upstream FastRPC, and which gaps remain before an OEM ships. Dates stay unconfirmed.
-
What SK hynix HBM5 Validation on TSMC CoWoS Means for the AI Supply Chain
Per SK hynix’s 2026-09-28 Newsroom post, TSMC named SK hynix Partner of the Year (3DFabric-HBM Integration) for early HBM5 validation on CoWoS. This article covers validation stage, accelerator roadmap alignment, and Samsung/Micron structure—no mass-production claims, share figures, or stock tips.
-
AI Agent Context Budget: What to Summarize in Long Sessions
Minimum per-turn state, where progress notes and checklists live, and a restart prompt example. No pricing, token, or context-window numbers.
-
AI Agent Secret Hygiene: Never Put Keys in Rules
Keep credentials out of Cursor rules and AGENTS.md. Where .env, keychain, Cloud Secrets, and allowlists live, plus a leak checklist. No real keys or pricing.
-
Slack MCP Agents: Split Read-Only from Send
Start Slack MCP read-only, gate sends behind confirmation UX, and why channel invites matter. No pricing, tokens, or invented Slack click-paths.
-
AI Agent TDD Loop: Fix the Failing Test First
Lock an AI agent TDD loop to red→green→refactor: how to feed failing logs, one-cycle done criteria, and stop rules for infinite fix loops. No pricing.
-
Cursor Cloud Agent vs Local Agent: When to Use Which
How to split Cursor Cloud Agent and the local chat Agent: Cloud for PR/long jobs, local for interactive edits, plus handoff. No pricing.
-
How to Turn a Linear Issue into a Cursor Agent PR
What to copy from a Linear issue into a Cursor agent, a PR description template, and when to request review. No pricing.
-
Why Is Micron HBM a Bottleneck for AI Servers?
HBM becomes the AI-server bottleneck when GPU FLOPs outpace memory bandwidth, capacity, and packaging supply. This post sticks to Micron’s official HBM4 specs, IR/SEC disclosures, and the Sep 30, 2026 earnings timing—tech and guidance only, no stock tips.
-
Have Agents Reproduce Only Non-Flake Failures
Howto to filter retryable flake signals and prompt agents to reproduce and report only deterministic failures. Filter heuristics, minimal repro commands, report evidence. Fowler quarantine and CI-log process. No affiliates.
-
CLAUDE.md vs AGENTS.md: How Cursor Reads Them
How Cursor reads CLAUDE.md and AGENTS.md, always-apply vs conditional .mdc rules, and where mixed teams should put each file—per official Rules docs. No pricing.
-
Cursor .cursor/agents vs Rules — How Do You Split Responsibilities?
Howto for Cursor .cursor/agents vs rules boundaries: what belongs in agents, what belongs in rules, what breaks when they overlap. Grounded in official Agents/Rules docs. No affiliates.
-
Cursor Hooks: What You Can Run Before and After the Agent
Cursor hooks how-to for the agent lifecycle—before/after events, hooks.json, and /create-hook—from official Hooks docs. Not a retell of the save/commit guard post.
-
Cursor Skills vs Rules: When to Use Which
Decide Cursor Skills vs Rules from official docs: alwaysApply and globs triggers, and what /migrate-to-skills moves (and leaves alone). No pricing.
-
OpenAI Pro $200 is reopening — why does the limit look like half?
OpenAI Pro $200 subscriptions reopen on 2026-09-30. Here is why the new usage accounting can look like half the old allowance in API dollars, how the claim that you still get more done holds up, and what happens to the 5-hour cap and the previewed perks.
-
How to Have an Agent Implement from an ADR Alone?
Agent ADR implementation: required sections (MADR), limiting code scope, verification steps. Howto for ADR-only delegation. No pricing or affiliates.
-
What Is /var For on Embedded Linux?
A board-level guide to /var on embedded Linux: what FHS says it is for, and how to split log, cache, lib, spool, run, and tmp between tmpfs and persistent storage when you have flash wear, a read-only root, and journald to deal with.
-
How to Debug When gpiochip Numbers Shift
Debug gpiochipN renumbering across boots/kernels: pin by label/name via /dev/gpiochip, libgpiod, /sys/bus/gpio. No invented board timings or affiliates.
-
Putting /var/log on tmpfs on embedded — when does it make sense?
fstab example for /var/log on tmpfs, what reboot does to logs, journald Storage=volatile. Grounded in fstab and journald.conf. No affiliates.
-
udev ACTION=add vs change — Why Rules Run Twice
udev ACTION add vs change, stop duplicate RUN, verify with udevadm monitor. Grounded in systemd udev ACTION keys. No affiliates.
-
Clean the Git Worktree Before Handing Off to an Agent
Checklist to clean or isolate a dirty git worktree before agent handoff: why clean first, how to mark remaining dirty. Grounded in git-worktree(1). No affiliates.
-
Enforce a Git Status Gate After Agent Work
Agent git status check: where to place it, whether to stop on a dirty tree, and intentional untracked allowlists. Grounded in git status --porcelain and hooks/commands. No pricing or affiliates.
-
cgroup v2 memory.max — How Do You Cap Process Memory?
Howto for cgroup v2 memory.max: where to write, OOM symptoms via memory.events, and how containers differ. Grounded in the kernel cgroup-v2 memory controller docs. No affiliates.
-
A week with ChatGPT Sol and Luna at work — what actually felt different
A hands-on review of a week spent alternating between the options labeled Sol and Luna in the ChatGPT model picker. Where Sol earned its wait on heavy reasoning, where Luna was simply enough for daily drafting, and what disappointed — no benchmarks, just how it felt.
-
Claude Code /compact — What Do You Keep When Context Shrinks?
Before Claude Code compact: minimum state, restart prompts, and what belongs in files. Grounded in /compact, /context, and CLAUDE.md re-injection. No pricing or affiliates.
-
What Claude Code Router is and how to use it
Claude Code Router (CCR) is a local router that sends Claude Code and similar coding-agent requests to the providers and models you choose. This guide covers when you need it, how the config is structured, how to pick models and verify the route, and the most common mistakes.
-
Cursor Custom Subagents — Where Do You Define Them?
Howto for Cursor custom subagents: file locations, when to delegate, what stays in the parent prompt. Grounded in official Subagents docs. No pricing or affiliates.
-
Calling Cursor-like agents from Grok Bot to get work done
Grok Bot does not have to do all coding inside chat. It can delegate repo edits and PR creation to Cursor-style cloud or local agents. What delegation means, good task shapes, limits, and a practical blog/dev ops workflow.
-
What to configure first when running a local coding agent with herdr
Before any orchestration, a local herdr setup needs a work root, a clear place for model settings, permissions and deny paths, and a way to hand tasks to agents. A first-settings checklist and common first-week mistakes, based on the official herdr docs as of 2026-09-27.
-
strace -e trace= — How Do You Filter Syscalls?
Howto for strace -e trace=: filter syntax, %file/%net for file and network only, performance cost and --seccomp-bpf. Grounded in strace(1). Separate from a full intro. No affiliates.
-
Prompting Agents for Git Rebase Conflicts
How to safely hand only rebase conflict hunks to an agent: pass conflict files, success criteria, when humans must resolve. Grounded in git rebase docs. No pricing or affiliates.
-
What Is Claude Opus 5.5 — How Does It Differ from Opus 5 for Agent Coding?
Claude Opus 5.5 (model id claude-opus-5-5, shipped 2026-09-22) is the upgrade question for people whose coding-agent daily driver is still Opus 5.
-
Cursor @Folder Scope — When to Attach a Directory
Howto for choosing file vs folder with Cursor @-mentions: too-wide symptoms, monorepo minimum scope. Grounded in official @ mentions docs. No pricing or affiliates.
-
What Is GPT-6 Astra — Computer-Use Agents and the Critical Cyber Tier
GPT-6 Astra is the frontier computer-use model you choose when you are ready to hand an agent the OS, browser, and long-running work—not merely a smarter chat model.
-
MCP Elicitation: When Should an Agent Ask the User Back?
Tool failure vs MCP elicitation, minimal question schema design, and accept/decline/cancel/timeout handling. Grounded in elicitation/create. No pricing or affiliates.
-
Embedded Serial Console Getty — How Do You Enable It?
Minimal howto to attach a login getty on a serial console: serial-getty@ unit and device, baud/TERM, what to check when the screen is blank. Grounded in systemd-getty-generator and kernel console=. No affiliates.
-
Yocto IMAGE_INSTALL vs RDEPENDS — Where Does the Package Go?
Put intentional image members in IMAGE_INSTALL; put hard runtime needs in RDEPENDS. Duplicating both breaks removal and audits. Grounded in the Yocto mega-manual.
-
How to Save Agent stdout to a Log File
Howto for reproducible agent stdout/stderr logs: where to redirect, keep failures only, read them next session. Grounded in shell redirect and tee. No pricing or affiliates.
-
How .cursorignore Shrinks What Cursor Indexes
Use .cursorignore to keep large artifacts, secrets, and build output out of Cursor indexing and agent context. Covers .gitignore differences, build patterns, and symptoms when the agent cannot read a file—no pricing or anecdotes.
-
Multi-Agent PRs: Branch Rules That Keep Reviews Sane
Split one branch per agent, keep humans as the merge gate, and cut conflicts with path ownership and frequent rebases. Practical multi-agent PR workflow—no pricing or personal anecdotes.
-
overlayroot vs A/B Updates: What to Pick on Embedded Linux
Choice criteria for Ubuntu overlayroot (read-only lower root plus overlay) versus A/B slot OTA—failure modes, OTA fit, and development images—grounded in public docs. Not Device Tree Overlay debugging.
-
Why Run ripgrep Before Agent Codebase Search
How to narrow scope with rg before handing a whole repo to an agent. ripgrep glob/type vs agent codebase search, and how to paste hits into prompts. No pricing or affiliates.
-
Agent Output Eval Checklist
Pre-merge eval of agent output: feature/regression, security/secrets, docs/commit messages. Separate axis from agent-diff-review (read order). No pricing or affiliates.
-
Device-Tree Alias·Label Debugging — What to Check and How to Align
Device Tree /aliases vs DTS labels vs nodes, plus debug tips. Grounded in the DT Spec and Linux OF APIs. No board measurements, pricing, or affiliates.
-
Issue→Branch Naming Rules — Prefix, Issue Number, Collisions
Rules so agents name branches from issues consistently: prefix, issue number, collision handling. Common git/GitHub branch practice. No pricing or affiliates.
-
journald Vacuum: How to Shrink Disk Usage
Use journalctl --vacuum-size/--vacuum-time/--vacuum-files to trim archived journals, then cap growth with Storage and SystemMaxUse. Disk retention howto—not filter queries.
-
MCP Tool Schemas: Helping Agents Call Them Correctly
How to write MCP tool descriptions, required fields, and failure messages so agents misuse tools less. Schema design howto—not connection troubleshooting.
-
Resume an OpenCode Session After You Stop
Find session IDs, resume with --continue/--session, compact with /compact, and fork with --fork—grounded in official OpenCode CLI and TUI docs.
-
Giving Agents the API Spec Only (OpenAPI)
Pass agents OpenAPI only to cut invented endpoints and hallucinations: where to put the spec, how to supply response examples, how to reduce hallucinations. OpenAPI 3.1 practice. No pricing or affiliates.
-
Long-Job Checkpoints: How to Resume After an Interrupt
Where to save agent checkpoint files, resume prompts, and context-loss recovery. Separate axis from context-budget and opencode session resume. No pricing.
-
Agent Deny Path Lists — Secrets, Vendor, Bypass Detection
How to put secrets/vendor deny paths on agents: .gitignore, .cursorignore, and detecting bypass. Public ignore practice. No pricing or affiliates.
-
Reviewing Agent Diffs Like a Human
Human review checklist for agent-written diffs—what to check first, merge without tests?, rollback criteria. Separate axis from multi-agent-pr (branches/gates). No pricing.
-
Make Agents Split Commits by Patch
Rules so agents split large changes into patch-sized commits: one-commit criteria, message format, separating mixed changes. Grounded in git add -p and atomic-commit practice. No pricing or affiliates.
-
BitBake bbappend: Patch Recipes Without Overwriting
Use .bbappend instead of copying upstream .bb files. Path layout, FILESEXTRAPATHS, and BBFILE_PRIORITY only. Separate axis from yocto-systemd. Grounded in Yocto docs.
-
Minimizing a Buildroot defconfig — What to Drop, Deps, savedefconfig
How to shrink a Buildroot defconfig: what to turn off, dependency breakage, and reproducing with savedefconfig. Grounded in the Buildroot manual. No invented board footprints or affiliates.
-
Codex CLI vs Claude Code: How to Split Terminal Agent Roles
Codex centers on AGENTS.md and config.toml sandboxing; Claude Code on CLAUDE.md, permissions, hooks, and subagents. Split by branch/worktree and form a triangle with the IDE agent.
-
Cursor Notepads: How to Use Them for Agent Context
Notepads were removed in Cursor 2.0. Move reusable context into Rules, Skills, Memories, or repo Markdown. Covers Notepad vs rules, when to create, and team sharing.
-
Reading dmesg on Embedded Without an RCU Deep Dive
How to read embedded dmesg around log levels, timestamps, and repeating panic patterns. Grounded in dmesg(1) and printk docs. No invented board stories or affiliates.
-
Injecting a Repo Map into the Agent
Which files belong in an agent repo map, how to auto-generate drafts, and how to retire stale maps. Separate axis from prompt-layers and Instant Grep. No pricing.
-
systemd Socket Activation: Delay-Start a Service
Open the listening socket first; start the service on traffic. Accept= meaning; vs timer and path. Grounded in man systemd.socket. No affiliate.
-
How to Install a systemd Service in a Yocto Recipe
Use inherit systemd and SYSTEMD_SERVICE:${PN}, install units under ${D}${systemd_system_unitdir}, and enable image init with INIT_MANAGER = "systemd".
-
Have the Agent Write the PR Body
Agent PR body: template sections, diff-based summary, reviewer checklist. Separate from multi-agent-pr (branches) and linear-to-agent-pr (issue handoff). No pricing or affiliates.
-
Minimal AGENTS.md Template: What to Write in the Repo First
Start with overview, setup/test commands, code style, and security only. Share exact commands with CLAUDE.md; split long guidance into nested AGENTS.md files.
-
Docker BuildKit Cache Mounts: How to Speed Up Builds
Use RUN --mount=type=cache for npm/Go/apt package caches across builds. Split buckets with id, use sharing=locked for apt, and pair with external cache in CI.
-
BusyBox vs coreutils: What to Pick on Embedded
BusyBox multi-call vs GNU coreutils: size/compat, script breakage, selection criteria. Grounded in BusyBox/coreutils public docs. No invented board stories or prices. No affiliates.
-
Claude Code Permissions and Network Allowlists: How to Narrow Them per Project
Put shared allow/deny rules in .claude/settings.json. Evaluate deny→ask→allow; gate the network with WebFetch(domain:) plus sandbox domains. Cursor rules describe intent; permissions enforce it.
-
CLI Quota Exhausted: How Do You Order the Fallback?
AI CLI quota fallback—symptoms, model-switch criteria, how to cut work cleanly. Spending / usage UI only. No price numbers or invented reviews.
-
A Flake-Only Retry Loop for Agents
Flake test agents: retry limits, isolation, and when to file an issue. Separate axis from agent-test-gate (pass/fail barrier) and agent-tdd-loop (write red→green). No pricing or affiliates.
-
mdev vs udev: What Fits a Small Embedded Rootfs
BusyBox mdev vs udev/systemd-udevd on a small embedded rootfs: when mdev fits, when udev is required, rule-migration caveats. Grounded in BusyBox mdev and udev public docs. No invented board stories or prices. No affiliates.
-
Picking the Agent Root in a Monorepo
Monorepo agent root: choose cwd, package scope, and wrong-root symptoms. Separate axis from repo-map-inject (map injection). No pricing or affiliates.
-
How to Split System, User, and Project Prompts
Agent prompt layers—what goes where, conflict precedence, and when to split long rules. No Skills/Rules retell, no commands how-to, no pricing.
-
What Brief Do You Give When Delegating to a Subagent?
Subagent delegation brief—success criteria, context to include, how to receive results. Separate axis from context-budget (session progress). Grounded in Cursor Subagents docs. No pricing.
-
sysfs GPIO vs libgpiod: When to Use Which
sysfs `/sys/class/gpio` is an obsolete migration path; new work uses `/dev/gpiochipX` + libgpiod. Selection axis, benefits, and permissions only—no gpiomon-edge or libgpiod howto rehash.
-
udev Input Device Permissions: How to Pin dialout and plugdev
Put tty/hid rules in /etc/udev/rules.d, match ATTRS{idVendor/idProduct}, set GROUP=dialout and SYMLINK, then verify with udevadm info/test/trigger.
-
USB Serial udev Symlink: How to Pin `/dev/ttyUSB`
Pin a stable path with SYMLINK when ttyUSB enumeration order shifts. ATTR/ATTRS keys, GROUP/MODE, udevadm verify/test/trigger only. No general udev tour or invented board stories.
-
Put a Test Gate on Agent Output
Agent test gate: where to check, whether to stop on fail, and how it overlaps with CI. Separate axis from agent-tdd-loop (write loop) and agent-eval-checklist (merge eval). No pricing or affiliates.
-
Using AI on Excel and Spreadsheets
Lock cleanup and classification first, take formulas and pivots as drafts, then verify with totals, row counts, and samples. Paid sheet-AI prices are omitted.
-
AI Workflows for Google Drive and Docs
In Drive and Docs, take summaries and drafts as jobs, lock folder rules, and keep sharing permissions as a human gate. Paid add-on prices are omitted.
-
Using AI for Meeting Notes and Email
Lock meeting-note structure (decisions, open items, actions), split email drafts by purpose and banned phrases, then a person checks tone and facts.
-
Checklist for Search-Only Users — What to Learn Next
A checklist for leaving search-only habits, what to learn next, and how to pick an agent — without prices or rankings.
-
Delegating File Cleanup and Repetitive Work to Agents
Delegate only closed-rule repetition, choose local vs cloud by permission and backup, and prevent mistakes with dry-runs, samples, and rollback.
-
Cursor Composer vs Agent: When to Switch
Composer is Cursor’s agentic model; Agent is the tool-using mode. When to pick Composer, when to run Agent, and mid-task switch criteria. No pricing.
-
Cursor Background Agent vs Local: When to Use Which
Cursor Background Agent workflow: when to go background, vs local, and how to review. Separate axis from weekly cursor-cloud-vs-local-agent (Cloud/PR VM). No pricing or affiliates.
-
Turn Frequent Prompts into `.cursor/commands`?
Where Cursor custom slash-command files live, how trailing args work, and how they differ from rules. No Skills retell, no pricing.
-
Cursor Hooks: How to Guard the Agent Before Saves and Commits
Put project hooks in .cursor/hooks.json and user hooks in ~/.cursor/hooks.json. Use afterFileEdit for formatters and beforeShellExecution for shell gates; block with deny, exit 2, or failClosed.
-
Git Worktree for Agent Isolation
How to isolate agents with linked git worktrees: create, branch rules, pre-merge checks. Different axis from multi-agent-pr-workflow (PR/review). No pricing.
-
libgpiod Edge Events: How to Catch Them with gpiomon
Use gpiomon --edges for rising, falling, or both; pass --chip with offsets; add --debounce-period for chatter. Unlike polling, it waits on kernel edge events.
-
When an Agent Status Freezes in a Herdr Pane, Where Do You Look?
If a sidebar status looks stuck, run herdr agent explain, separate client detach from server restarts, then inspect output with agent/pane read.
-
MCP Auth Fail: What to Do on needsAuth
If the server shows needsAuth and tools are empty, that is auth—not a missing mcp.json. Symptoms, reconnect order, empty tool list. No pricing or token values.
-
MCP Resource vs Tool: When to Use Which
MCP resource vs tool selection: when resource, when tool, when both. Separate from mcp-tool-schema (schema design) and mcp-auth-fail (needsAuth). No pricing or affiliates.
-
Attaching a Local Coding Agent with OpenClaw: The Minimum Setup
Keep OpenClaw config under ~/.openclaw and run the Gateway, point local models at Ollama’s native endpoint, and opt in to the coding-agent skill with Claude Code, Codex, or OpenCode.
-
How to Use Agents in Real Work: An Overview
Search gathers answers; agents execute work. Split what you delegate from the checkpoints a person still owns.
-
Using AI Agents for PPT and Slides
Lock the outline first, split speaker copy from slide bullets, and keep design, figures, and brand as human gates. Paid PPT-tool prices are omitted.
-
How to Use ThreadSanitizer to Find C++ Data Races
Build and link with -fsanitize=thread so ThreadSanitizer reports data races at run time. Read Write/Previous write stacks and thread creation sites, and keep AddressSanitizer in a separate build.
-
How to Use ftrace function_graph to See Kernel Call Paths
Set current_tracer to function_graph under tracefs, narrow the scope with set_ftrace_filter, then use tracing_on and trace or trace_pipe to read the call graph. Covers buffer, filters, and overhead only.
-
How to Use i2cdetect and i2cget to Find a Sensor Address
List adapters with i2cdetect -l on i2c-dev buses under /dev/i2c-*, scan slave addresses with i2cdetect, then read registers with i2cget. Covers permissions and the Device Tree boundary briefly.
-
Parallel Agents with Orca Worktrees
Create one git worktree per task with orca worktree create, pick the first-terminal agent with --agent, and treat isolation—not extra chats—as the parallel unit.
-
What is Orca CLI? Install and Run the First Commands
Orca CLI is the orca command that scripts a running desktop ADE. After the official install, verify with command -v orca and orca status --json.
-
From Search-Only ChatGPT to Agent Instructions
Turn a search sentence into a job with a goal, a scope, and a done-check. On failure, narrow the same goal instead of widening permission.
-
AArch64 Cross-Compile with CMake: How to Use a Toolchain File
For cross-compiling to a target board like aarch64, point CMAKETOOLCHAINFILE at a file that sets the target system and compilers, set CMAKESYSROOT to the target root filesystem, an
-
C++20 Ranges: Composable Views for Filtering and Transforming Sequences
C++20 ranges treats a sequence as a lightweight view so filtering, transforming, and sorting can be composed without copying elements.
-
Cursor MCP Connection Failures: What to Check When a Server Does Not Appear
When a Cursor MCP connection fails, first check MCP Logs in the Output panel (Cmd+Shift+U on Mac, Ctrl+Shift+U on Windows/Linux). Then verify the mcp.json path and environment vari
-
Claude Code Project Settings: Locking Down Rules and Tool Permissions
To lock down Claude Code settings per project, put permissions allow/ask/deny rules in a committed .claude/settings.json plus a personal .claude/settings.local.json. Verify what actually applies with /permissions and /status.
-
Using std::jthread and stop_token for Cooperative Thread Cancellation
C++20 std::jthread automatically calls join() on destruction and carries an internal std::stop_source for cooperative cancellation. This note covers auto-join behavior and how to pass and check a stop_token.
-
When to Switch Between Cursor Agent, Ask, and Plan Modes
Cursor Agent mode handles actual code editing, Ask mode specializes in codebase analysis and Q&A, and Plan mode strategizes multi-file changes. This article covers when to use each mode and what breaks when the wrong one is chosen.
-
Configuring MCP Servers in Cursor with mcp.json
To connect an MCP server in Cursor, configure it in an mcp.json file. This article covers file locations, writing server entries, and troubleshooting connection failures.
-
Filtering Service Logs with journalctl
journalctl is the core tool for querying the systemd journal. Use -u and -b to narrow by unit and boot, then --since, --until, and -p to filter by time and severity.
-
libgpiod: Userspace GPIO Access on Linux
libgpiod provides the userspace C library, language bindings, and command-line tools for interacting with GPIO lines through Linux's GPIO character device.
-
Setting Up systemd Timers with OnCalendar for Periodic Jobs
To run a periodic job, create a .timer unit that shares its base name with a .service unit and set OnCalendar= in the [Timer] section. This post covers timer-service pairing, calendar expressions, and catching up missed runs with Persistent=true.
-
A Tour of C++ 1.1 — What to grasp first when reading C++
A Tour of C++ §1.1 Introduction. Before memorizing syntax, hold notation, types, memory and computation models, and the mechanisms that build programs.
-
A Tour of C++ 2.6 — Advice: Choosing struct, class, enum, and variant
When built-in types are insufficient in C++, design and choose the appropriate user-defined type to group related data and prevent invalid states. This post summarizes when to use struct, class, enum class, and std::variant from Chapter 2.
-
A Tour of C++ 3.1 — Introduction: Declarations vs Definitions
In C++, a declaration tells the compiler enough to use a name, while a definition provides the actual implementation body. This post introduces the separation of interface and implementation from Chapter 3.
-
A Tour of C++ 3.2 — Separate Compilation: Headers vs C++20 Modules
Traditional #include headers cause repeated parsing and dependency leaks in separate compilation, while C++20 modules solve these overheads through single-time compilation and macro isolation.
-
Writing udev Rules: Fixing Device Names and Permissions
In Linux, udev dynamically manages device nodes and permissions. This post covers where rule files live, how to match devices with ATTR and KERNEL keys, and how to verify rules with udevadm.
-
AGENTS.md vs CLAUDE.md: Aligning Multi-Agent Rules in One Repo
Running more than one AI coding assistant against the same repository raises a question: how should AGENTS.md and CLAUDE.md relate to each other? This note covers role differences, sync strategies, and conflict resolution based on current official documentation.
-
Combining Cursor and Gemini Subscriptions with pi agent
A personal account of using pi agent as a hub to tie Cursor and Gemini subscriptions together for multi-model orchestration. Covers why one model was not enough and how custom workflows were built around each model's strengths.
-
A Tour of C++ 1.8 — Tests: Conditions, Short-Circuit, and Control Flow
A Tour of C++ §1.8 covers how C++ expresses selection and looping with if, switch, while, and for. This post clarifies truthiness, short-circuit evaluation, if-initialization, switch fall-through, and common control-flow mistakes.
-
A Tour of C++ 2.5 — Unions: Active Members and std::variant
A union lets several members share one block of memory to save space, but the programmer must track which member is currently valid. This post explains union hazards and why std::variant offers a type-safe alternative since C++17.
-
Setting Up a herdr Workspace to Run Multiple Agents Side by Side
A herdr workspace groups the tabs and panes for one project or task, letting you run several agents side by side in one place. This overview covers workspace creation, tab and pane layout, and official best practices.
-
A Tour of C++ 1.10 — Advice: C++ Coding Habits
C++ coding habits are not just new syntax—they are rules for consistently handling comments, initialization, naming, scope, and constants. This post concludes Chapter 1 with practical advice from Bjarne Stroustrup's study notes.
-
A Tour of C++ 1.9 — Mapping to Hardware: Pointers vs References
The core of C++ mapping to hardware is that basic operations translate directly into single machine instructions without extra runtime overhead. This article explains the memory model and the differences between pointers and references.
-
How Docker Containers Run: Namespaces and cgroups
A Docker container is not a virtual machine with its own kernel—it is a set of Linux processes isolated by namespaces and constrained by cgroups on the same host kernel. This article summarizes how docker run actually works based on official Docker documentation.
-
Loading and Running Docker Images with save, load, and run
When transferring images without a registry, use docker save and docker load to preserve every layer, history, and tag metadata. Once loaded locally, docker run follows the same execution path as a pulled image.
-
Docker Layer Cache, Volumes, and Bind Mounts in Practice
Docker reuses build cache from the top down, so frequently changing instructions belong at the bottom of the Dockerfile. Persistent data should live in volumes or bind mounts—not in the overlay writable layer that is destroyed when a container is removed.
-
Docker overlay2 Storage: How Image Layers Merge
Docker overlay2 uses OverlayFS to combine read-only image layers with a container-specific writable layer into a single mount point. This post explains how the storage driver stacks layers on disk and why container writes do not persist to the underlying image.
-
systemd Type= Explained: simple, exec, notify, and Key Service Keywords
The systemd Type= directive determines when the service manager considers start-up complete. This article covers all eight Type= values and essential service file keywords from the official man pages.
-
A Tour of C++ 2.1–2.2 — User-Defined Types and struct Vector
Built-in types are low-level tools that mirror hardware capabilities; user-defined types layer abstraction on top. This post covers the first step—grouping data with struct—and introduces the Tour's Vector example.
-
A Tour of C++ 2.3 — Classes: Enforcing Invariants with Constructors
A C++ class separates the public interface from private implementation and enforces invariants immediately upon object creation using a constructor. This article covers why struct Vector was insufficient and how a class fixes it.
-
A Tour of C++ 1.8 — Tests: Conditions, Short-Circuit, and Control Flow
A Tour of C++ §1.8 covers how C++ expresses selection and looping with if, switch, while, and for. This post clarifies truthiness, short-circuit evaluation, if-initialization, switch fall-through, and common control-flow mistakes.
-
Running Multiple Agents with Slash Commands in herdr
Based on official documentation, this article explains the herdr orchestrator workflow for having a script or agent create work for other coding agents, inspect their state, and collect results.
-
Profiling with Linux perf: Finding CPU Hotspots
Linux perf uses the kernel performance-counter framework to sample CPU activity and expose functions where samples accumulate as hotspots.
-
Formatting Output with C++ std::format
In C++20, std::format takes a format string, substitutes the supplied arguments, and returns formatted text. A safe, extensible alternative to printf and a complement to iostreams.
-
Managing a static blog with Astro Content Collections
How Astro 5 glob loaders and Zod schemas keep Markdown/MDX posts type-safe on a self-hosted branch site.