# stack

Published articles for stack.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Your First Virtual Machine: Write yourself a compiler, Part IV

DevFeed: [Your First Virtual Machine: Write yourself a compiler, Part IV](<https://devfeed.tech/articles/your-first-virtual-machine-write-yourself-a-compiler-part-iv-38040.md>)

Original publisher: [Read original article](<https://nurkiewicz.com/2026/08/your-first-virtual-machine-write-yourself-a-compiler.html>)

Published: 2026-08-24T22:00:00Z

Content type: tutorial

Language: en

Sources: [Tomasz Nurkiewicz around Java and concurrency](<https://devfeed.tech/sources/tomasz-nurkiewicz-around-java-and-concurrency.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [feature](<https://devfeed.tech/tags/feature.md>), [go](<https://devfeed.tech/tags/go.md>), [interpreter](<https://devfeed.tech/tags/interpreter.md>), [reverse-polish-notation](<https://devfeed.tech/tags/reverse-polish-notation.md>), [stack](<https://devfeed.tech/tags/stack.md>), [virtual-machine](<https://devfeed.tech/tags/virtual-machine.md>), [vm](<https://devfeed.tech/tags/vm.md>), [writing-compiler](<https://devfeed.tech/tags/writing-compiler.md>)

### AI overview

This tutorial explains how to build a virtual machine that reads and executes a binary intermediate representation. It covers the instruction loop, operand stack, arithmetic operations, postfix notation, and how the resulting executable compares with JVM files and .NET assemblies.

### Source excerpt

In the previous article, we emitted an intermediate representation (IR) for our programming language that is easier to process than source code. However, we did not build a program that could read and execute that IR. Such a program is called a virtual machine. Technically, it's still an interpreter. But instead of interpreting source code, it interprets IR. Our IR is binary, compact, structured, and generally faster to interpret than the original source. Moreover, as you'll see later, the VM's instruction set can express programs that our source language cannot produce yet!

## How fsync affects data durability, latency, and group commit

DevFeed: [How fsync affects data durability, latency, and group commit](<https://devfeed.tech/articles/fsync-is-the-only-thing-between-you-and-data-loss-and-it-is-slower-than-you-think-39589.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/37-fsync-durability-cost-group-commit/>)

Author: hello@ankit-rana.com

Published: 2026-08-14T00:00:00Z

Content type: article

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [NVMe](<https://devfeed.tech/topics/nvme.md>), [Replication](<https://devfeed.tech/topics/replication.md>)

Tags: [databases](<https://devfeed.tech/tags/databases.md>), [durability](<https://devfeed.tech/tags/durability.md>), [flush](<https://devfeed.tech/tags/flush.md>), [fsync](<https://devfeed.tech/tags/fsync.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [replication](<https://devfeed.tech/tags/replication.md>), [ssd](<https://devfeed.tech/tags/ssd.md>), [stack](<https://devfeed.tech/tags/stack.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

This article explains that a successful write() may leave data only in the kernel page cache, so a power loss can destroy it. It describes fsync as the operation that pushes data to the device, discusses its latency cost, and explains how group commit amortizes the synchronization barrier. It also distinguishes disk durability from replication across failure domains.

### Source excerpt

A successful write() only copies your data into the kernel page cache, where a power loss destroys it. Only fsync pushes it to the device, and because fsync is a barrier rather than a write, a system that syncs once per commit is capped at roughly one divided by the fsync latency, no matter how fast the rest of the stack is. Group commit exists to amortise that barrier, and replication solves a different failure domain than fsync does, which is why acks=all does not mean the data is on any disk.

## Inside Go -- Part 2: Memory Management in Go

DevFeed: [Inside Go -- Part 2: Memory Management in Go](<https://devfeed.tech/articles/inside-go-part-2-memory-management-in-go-39764.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/inside-go-part-2-memory-management-in-go>)

Author: Furkan Kolcu

Published: 2025-09-12T16:30:37Z

Content type: tutorial

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [escape analysis](<https://devfeed.tech/topics/escape-analysis.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [escape-analysis](<https://devfeed.tech/tags/escape-analysis.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [go](<https://devfeed.tech/tags/go.md>), [go-memory-management](<https://devfeed.tech/tags/go-memory-management.md>), [golang](<https://devfeed.tech/tags/golang.md>), [heap](<https://devfeed.tech/tags/heap.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [performance](<https://devfeed.tech/tags/performance.md>), [stack](<https://devfeed.tech/tags/stack.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This tutorial explains how Go manages memory through stack and heap allocation, escape analysis, and garbage collection. It also shows how compiler decisions affect performance and how to inspect escape analysis results.

### Source excerpt

A deep dive into how Go handles memory behind the scenes. Learn the difference between stack and heap, how escape analysis works, and why memory management plays a key role in performance.

## Impossible Components

DevFeed: [Impossible Components](<https://devfeed.tech/articles/impossible-components-36175.md>)

Original publisher: [Read original article](<https://overreacted.io/impossible-components/>)

Published: 2025-04-22T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dan Abramov](<https://devfeed.tech/sources/dan-abramov.md>)

Topics: [React](<https://devfeed.tech/topics/react.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [Framework](<https://devfeed.tech/topics/framework.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [components](<https://devfeed.tech/tags/components.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [react](<https://devfeed.tech/tags/react.md>), [stack](<https://devfeed.tech/tags/stack.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

This tutorial explains how React Server Components can compose backend and frontend code into a single component abstraction. It demonstrates top-down data flow from backend-loaded data to interactive frontend state, including independently rendered and editable instances.

### Source excerpt

Composing across the stack.

## Debugger Lies: Stack Corruption

DevFeed: [Debugger Lies: Stack Corruption](<https://devfeed.tech/articles/debugger-lies-stack-corruption-39722.md>)

Original publisher: [Read original article](<https://www.timdbg.com/posts/debugger-lies-part-1/>)

Author: Tim Misiak

Published: 2022-08-21T16:57:31Z

Content type: tutorial

Language: en

Sources: [TimDbg](<https://devfeed.tech/sources/timdbg.md>)

Topics: [debug](<https://devfeed.tech/topics/debug.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [MSVC](<https://devfeed.tech/topics/msvc.md>), [Security](<https://devfeed.tech/topics/security.md>), [Variable](<https://devfeed.tech/topics/variable.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [crash](<https://devfeed.tech/tags/crash.md>), [debug](<https://devfeed.tech/tags/debug.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [local-variables](<https://devfeed.tech/tags/local-variables.md>), [memory](<https://devfeed.tech/tags/memory.md>), [msvc](<https://devfeed.tech/tags/msvc.md>), [security](<https://devfeed.tech/tags/security.md>), [stack](<https://devfeed.tech/tags/stack.md>)

### AI overview

This article explains why debuggers can produce misleading stack walks, focusing on stack corruption caused by buffer overflows that overwrite return addresses. It discusses how MSVC's /GS security checks affect crash stacks and recommends enabling /GS, along with using memory access breakpoints to investigate corruption.

### Source excerpt

There are lots of reasons your debugger might be lying to you. Sometimes it's because information is lost when compiling due to optimizations. Sometimes the symbolic debug information isn't expressive enough. Other times it can be due to a bug in the debugger (although I hope that reason is rare). One frustrating case where the debugger sometimes "lies" to you is the stack walk. It's the single most important piece of information to come out of a crash, so when the stack walk is wrong, it's probably going to make analysis difficult.

## A random number you already have: The stack address

DevFeed: [A random number you already have: The stack address](<https://devfeed.tech/articles/a-random-number-you-already-have-the-stack-address-35369.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/a-random-number-you-already-have/>)

Author: Graham King

Published: 2022-06-05T23:19:39Z

Content type: article

Language: en

Sources: [Graham King](<https://devfeed.tech/sources/graham-king.md>)

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Python](<https://devfeed.tech/topics/python.md>), [macOS](<https://devfeed.tech/topics/macos.md>), [Security](<https://devfeed.tech/topics/security.md>), [Go](<https://devfeed.tech/topics/go.md>)

Tags: [go](<https://devfeed.tech/tags/go.md>), [linux](<https://devfeed.tech/tags/linux.md>), [macos](<https://devfeed.tech/tags/macos.md>), [number](<https://devfeed.tech/tags/number.md>), [performance](<https://devfeed.tech/tags/performance.md>), [python](<https://devfeed.tech/tags/python.md>), [random](<https://devfeed.tech/tags/random.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [stack](<https://devfeed.tech/tags/stack.md>)

### AI overview

This article explains how Address Space Layout Randomization can make a stack variable's memory address serve as a low-cost source of random bits. It describes address-bit handling in Rust and CPython, notes that the approach does not work the same way in Go, and connects the technique to hash-table randomization and denial-of-service resistance.

### Source excerpt

Thanks to Address Space Layout Randomization you can use the address of a stack variable as a zero-cost random number.

## Coroutines under the hood

DevFeed: [Coroutines under the hood](<https://devfeed.tech/articles/coroutines-under-the-hood-39241.md>)

Original publisher: [Read original article](<https://kt.academy/article/cc-under-the-hood>)

Published: 2021-09-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [functions](<https://devfeed.tech/topics/functions.md>), [union types](<https://devfeed.tech/topics/union-types.md>)

Tags: [continuation](<https://devfeed.tech/tags/continuation.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [functions](<https://devfeed.tech/tags/functions.md>), [internals](<https://devfeed.tech/tags/internals.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [stack](<https://devfeed.tech/tags/stack.md>), [state](<https://devfeed.tech/tags/state.md>), [union-types](<https://devfeed.tech/tags/union-types.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

A deep dive into Kotlin coroutine implementation details, explaining suspension as state machines and describing how continuations preserve local state and represent the call stack. It also introduces continuation-passing style and the altered result types used under the hood.

### Source excerpt

A deep dive into how suspension and continuations work under the hood.

## Depth- and Breadth-First Search

DevFeed: [Depth- and Breadth-First Search](<https://devfeed.tech/articles/depth-and-breadth-first-search-40300.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2013/01/22/depth-and-breadth-first-search/>)

Published: 2013-01-22T11:44:27Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Graphs](<https://devfeed.tech/topics/graphs.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [breadth-first-search](<https://devfeed.tech/tags/breadth-first-search.md>), [computer](<https://devfeed.tech/tags/computer.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [depth-first-search](<https://devfeed.tech/tags/depth-first-search.md>), [graph-theory](<https://devfeed.tech/tags/graph-theory.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [queue](<https://devfeed.tech/tags/queue.md>), [stack](<https://devfeed.tech/tags/stack.md>)

### AI overview

This tutorial introduces graph search through depth-first search and breadth-first search. It reviews directed graphs, vertices, edges, adjacency functions, and implementations of the basic graph data structure in mathematical terms and Python.

### Source excerpt

The graph is among the most common data structures in computer science, and it's unsurprising that a staggeringly large amount of time has been dedicated to developing algorithms on graphs. Indeed, many problems in areas ranging from sociology, linguistics, to chemistry and artificial intelligence can be translated into questions about graphs. It's no stretch to say that graphs are truly ubiquitous. Even more, common problems often concern the existence and optimality of paths from one vertex to another with certain properties.