# internals Published articles for internals. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## 9 GPU Concepts Every AI Engineer Should Know DevFeed: [9 GPU Concepts Every AI Engineer Should Know]() Original publisher: [Read original article]() Author: Dr. Ashish Bamania Published: 2026-08-31T15:19:52Z Content type: tutorial Language: en Sources: [Dr. Ashish Bamania]() Topics: [GPU](), [PyTorch](), [Large Language Model](), [Artificial Intelligence]() Tags: [ai-engineer](), [artificial-intelligence](), [coding](), [compute](), [cpu](), [data-science](), [gpu](), [guide](), [internals](), [llms](), [machine-learning](), [nvidia](), [programming](), [pytorch](), [technology]() ### AI overview A practical guide to nine GPU concepts relevant to AI engineers. It introduces GPU computation hardware, memory, program execution, and multi-GPU connections, including streaming multiprocessors in NVIDIA GPUs and their role in parallel computation. ### Source excerpt A simple and practical guide to GPU internals that AI engineers actually need. Continue reading on Level Up Coding " ## Perturbation Probing: A New Diagnostic for the Fragility of LLM Safety DevFeed: [Perturbation Probing: A New Diagnostic for the Fragility of LLM Safety]() Original publisher: [Read original article]() Author: Tony Li, Hongliang Liu and Yuhao Wu Published: 2026-08-28T22:00:07Z Content type: article Language: en Sources: [Unit 42]() Topics: [Large Language Model](), [ai safety](), [Machine Learning, Security Attacks](), [Security](), [Artificial Intelligence](), [Reinforcement learning](), [human feedback]() Tags: [ai](), [ai-safety](), [benchmark](), [benchmarks](), [external](), [general](), [insights](), [internals](), [jailbreak](), [llm](), [llms](), [model](), [optimization](), [research](), [safety](), [security]() ### AI overview The article presents perturbation probing, a low-cost method for identifying neurons causally responsible for targeted behaviors in aligned large language models. It reports that very small neuron subsets control refusal or false-agreement behaviors, suggesting that LLM safety can be fragile and concentrated rather than broadly distributed. ### Source excerpt New research reveals that AI safety refusal lives in a thin neural layer, highlighting the critical need for external, multi-layered security. The post Perturbation Probing: A New Diagnostic for the Fragility of LLM Safety appeared first on Unit 42. ## GPU Concepts and Internals for AI Engineers DevFeed: [GPU Concepts and Internals for AI Engineers]() Original publisher: [Read original article]() Author: Dr. Ashish Bamania Published: 2026-08-27T12:16:32Z Content type: tutorial Language: en Sources: [Into AI]() Topics: [GPU](), [Artificial Intelligence]() Tags: [ai-engineer](), [concepts](), [gpu](), [guide](), [internals]() ### AI overview A practical guide to GPU internals and concepts relevant to AI engineers. ### Source excerpt A simple and practical guide to GPU internals that AI engineers actually need. ## What is a data topology? DevFeed: [What is a data topology?]() Original publisher: [Read original article]() Author: Ahmed Darwich Published: 2026-08-17T00:00:00Z Content type: article Language: en Sources: [Blog -- PlanetScale]() Topics: [data](), [vitess]() Tags: [architecture](), [data](), [database](), [engineering](), [internals](), [json](), [mapping](), [neki](), [performance](), [postgres](), [postgresql](), [routing](), [scalability](), [transactions](), [vitess]() ### AI overview The article explains Neki data topologies: JSON configurations that map logical PostgreSQL tables to physical shard groups so routers can place data and route queries. ### Source excerpt A data topology describes the sharding scheme a Neki router uses to map logical PostgreSQL tables to physical shards and route queries. ## Kubernetes Control Plane Internals and Reconciliation DevFeed: [Kubernetes Control Plane Internals and Reconciliation]() Original publisher: [Read original article]() Author: Alexandre Zajac Published: 2026-08-03T15:31:23Z Content type: tutorial Language: en Sources: [Hungry Minds]() Topics: [Kubernetes](), [distributed-systems](), [Containers]() Tags: [container](), [internals](), [kubernetes](), [reconciliation](), [scheduler]() ### AI overview This article explains how Kubernetes manages distributed workloads through its control plane, worker nodes, and reconciliation loop. It covers the API server, etcd, scheduling, kubelet, desired-versus-actual state, and automated recovery. ### Source excerpt PLUS: Ray 2x throughput boost ⚡, take-home interview breakdown 🔬, great work principles 📚 ## How the controller-runtime Cache Actually Works, and Why Your Controller Does Not Crash the API Server DevFeed: [How the controller-runtime Cache Actually Works, and Why Your Controller Does Not Crash the API Server]() Original publisher: [Read original article]() Author: Andrei Kvapil; Timofei Larkin Published: 2026-07-29T18:00:00Z Content type: article Language: en Sources: [Kubernetes Blog]() Topics: [Kubernetes](), [Go Language](), [Cache](), [Caching]() Tags: [article](), [cache](), [go](), [golang](), [internals](), [kubernetes](), [memory](), [network]() ### AI overview This article explains how the controller-runtime cache works in Kubernetes controllers written in Go. It describes the local in-memory cache populated by list and watch operations, contrasts cached reads with direct API-server access, and examines the practical effects on memory usage, network traffic, read consistency, and reconciler behavior. ### Source excerpt This article has been revised since it was first published, to correct several significant technical inaccuracies in the original text. Kubernetes has long been the default platform for distributed workloads, and writing your own controller for it is now a matter of a few hours. The common path -- Golang, using kubebuilder on top of controller-runtime -- gives you a project scaffold, types, and a reconciler. For typical scenarios that is more than enough. But as soon as load grows or the controller starts behaving in ways you did not expect, a whole class of edge cases shows up. Most of them trace back to the same root cause: a fuzzy mental model of how controller-runtime works inside. If you write Kubernetes controllers in Go, this article should help you build a coherent picture and avoid expensive surprises in production. This article walks through the internals of controller-runtime and, along the way, shows which architectural decisions are baked into Kubernetes itself. The starting point is how controllers actually read objects from the Kubernetes API. A common misconception goes like this: r.Get() inside Reconcile queries kube-apiserver directly; r.List() returns a fresh, live view of the world; and after r.Update() you can re-read the object and immediately see the new state. In practice the model is the opposite: controller-runtime operates against a local copy of the data populated through list + watch. Reads inside a reconciler cost almost nothing and do not load the control plane even at hundreds of calls per second -- but the price of this design is that a controller can quietly consume gigabytes of memory, perform hidden O(n) scans, and regularly trip over stale reads. This post is aimed at engineers who already write controllers in Go with controller-runtime but want to consolidate the pieces into a single mental model rather than carry around a bag of isolated observations. The focus is the practical impact on production clusters: memory, network traffi ## Unbiased Java CPU profiling with JFR in JDK 25 DevFeed: [Unbiased Java CPU profiling with JFR in JDK 25]() Original publisher: [Read original article]() Author: Jaroslav Bachorík; Scott Gerring Published: 2026-07-22T00:00:00Z Content type: article Language: en Sources: [Datadog | The Monitor blog]() Topics: [cpu]() Tags: [agents](), [amazon](), [community](), [cpu](), [event](), [internals](), [java](), [latency](), [optimization](), [performance](), [production](), [sap](), [scale](), [traces]() ### AI overview The article explains why existing JVM sampling can misrepresent CPU-bound hotspots and describes a new JFR CPU profiling event introduced in JDK 25. ### Source excerpt Modern Java profilers often rely on unsupported JVM internals for accurate CPU profiling. Here's how engineers from Datadog, SAP, Amazon, and the OpenJDK community helped bring a new CPU profiling event to JDK 25. ## Inside SubcomposeLayout: Jetpack Compose's Most Misunderstood API DevFeed: [Inside SubcomposeLayout: Jetpack Compose's Most Misunderstood API]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2026-07-10T12:05:00Z Content type: article Language: en Sources: [Shreyas Patil's Blog]() Topics: [Jetpack Compose](), [Compose](), [ui]() Tags: [android](), [android-app-development](), [compose](), [declarative](), [deep-dive](), [internals](), [jetpack-compose](), [kotlin](), [learn](), [performance](), [performance-optimization](), [ui](), [uiux]() ### AI overview A deep dive into Jetpack Compose's SubcomposeLayout, explaining how it performs composition during measurement or placement, stalls the normal layout pipeline, and can create performance costs. The article also outlines when standard custom layouts or SubcomposeLayout are appropriate. ### Source excerpt A deep dive into the internals of SubcomposeLayout in Jetpack Compose. Learn how subcomposition actually works, why it breaks the phase rules, and the real node-thrashing cost it carries. ## Exploring CompositionLocal API internals in Jetpack Compose DevFeed: [Exploring CompositionLocal API internals in Jetpack Compose]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2026-03-09T05:19:42Z Content type: article Language: en Sources: [Shreyas Patil's Blog]() Topics: [Compose](), [Jetpack Compose](), [API](), [Kotlin](), [Code]() Tags: [android](), [android-development](), [compose](), [data](), [deep-dive](), [implementation](), [internals](), [jetpack](), [jetpack-compose](), [kotlin](), [source]() ### AI overview A deep dive into Jetpack Compose's CompositionLocal API, explaining how values flow implicitly through the composition tree and how the system is implemented with class hierarchies, value holders, persistent maps, and Composer integration. ### Source excerpt Deep dive into the internals of Jetpack Compose's CompositionLocal API. Trace how data flows implicitly through the composition tree under the hood. ## Practical Kotlin Deep Dive: A Book and Course on Kotlin Internals DevFeed: [Practical Kotlin Deep Dive: A Book and Course on Kotlin Internals]() Original publisher: [Read original article]() Author: Jaewoong Eum Published: 2026-02-18T03:55:53Z Content type: article Language: en Sources: [Stories by Jaewoong Eum on Medium]() Topics: [Kotlin](), [Compiler](), [Code](), [Development]() Tags: [analysis](), [android](), [bytecode](), [compiler](), [internals](), [kotlin](), [kotlin-coroutines](), [programming](), [technical](), [technical-interview]() ### AI overview This article introduces Practical Kotlin Deep Dive, a book and companion course focused on Kotlin internals. It describes coverage of bytecode decompilations, compiler source code, KEEP proposals, code examples, Code Playgrounds, and quiz questions across six chapters. ### Source excerpt Most Kotlin developers can write a data class, launch a coroutine, or use lazy without thinking twice. These features work, the code compiles, and the app runs. But there is a gap between knowing how to use Kotlin and understanding what the compiler actually does with your code. That gap is where performance intuition, debugging skill, and technical interview confidence come from. Practical Kotlin Deep Dive is a book designed to close that gap, covering 70 Kotlin topics across 492 pages with bytecode decompilations, compiler source code references, and KEEP proposal analysis that reveal the machinery behind every feature you use daily. In this article, you'll explore what the book and its companion course cover, walking through each of the six chapters with examples of the insights you'll find inside. You'll see how the book approaches topics differently from typical Kotlin resources, what the "Pro Tips for Mastery" sections reveal about internal mechanisms, and how the interactive course format turns that knowledge into verified understanding through Code Playgrounds and 158 quiz questions. Beyond the syntax: Why internals matter Knowing that lazy caches a value on first access is useful. Knowing that the default lazy implementation uses double checked locking with a synchronized block, and that you can switch to a lock free compareAndSet strategy by passing LazyThreadSafetyMode.PUBLICATION, is the difference between using a feature and making informed decisions about it. The same applies across the language. Understanding that every lambda passed to a higher order function creates a Function object on the heap explains why inline exists. Seeing a data class decompiled into seven generated methods explains what the compiler is doing on your behalf. This is the approach Practical Kotlin Deep Dive takes throughout. Rather than describing what Kotlin features do, it examines how they work internally, what bytecode they produce, what design trade-offs the language desi ## Taming PostgreSQL GUC "extra" Data DevFeed: [Taming PostgreSQL GUC "extra" Data]() Original publisher: [Read original article]() Author: David Wheeler Published: 2025-12-18T00:00:00Z Content type: article Language: en Sources: [ClickHouse Blog]() Topics: [PostgreSQL](), [clickhouse](), [Parser](), [Code](), [API]() Tags: [c](), [clickhouse](), [code](), [internals](), [postgres](), [postgresql](), [tutorial]() ### AI overview This article explains how pg_clickhouse optimized a PostgreSQL GUC that passes key/value session settings to ClickHouse. It describes replacing per-query string parsing with pre-parsed data stored when the setting is assigned, and discusses the PostgreSQL GUC API, memory allocation, validation, and assignment hooks involved in the implementation. ### Source excerpt Postgres ## How we scaled raw GROUP BY to 100 B+ rows in under a second DevFeed: [How we scaled raw GROUP BY to 100 B+ rows in under a second]() Original publisher: [Read original article]() Author: Tom Schreiber Published: 2025-09-29T00:00:00Z Content type: article Language: en Sources: [ClickHouse Blog]() Topics: [AI, ML & Data Engineering]() Tags: [analytics](), [benchmark](), [bigquery](), [clickhouse](), [cloud](), [internals](), [performance](), [scale](), [spark]() ### AI overview ClickHouse Cloud introduces parallel replicas to distribute a single analytical query across cluster cores, aiming to scale GROUP BY workloads horizontally without data reshuffling. ### Source excerpt ClickHouse Cloud now scales analytical queries with parallel replicas, fanning a single query across thousands of cores for terabyte-per-second throughput. This post dives into the internals and lets you see and feel the speed. ## Inside Go -- How It Really Works: Series Kickoff DevFeed: [Inside Go -- How It Really Works: Series Kickoff]() Original publisher: [Read original article]() Author: Furkan Kolcu Published: 2025-09-11T10:16:52Z Content type: article Language: en Sources: [Furkan Kolcu - Software Engineer Blog]() Topics: [Go Language](), [Compiler](), [Concurrency](), [Code](), [Optimization](), [escape analysis](), [generics](), [modules](), [reproducible builds]() Tags: [compilation](), [concurrency](), [deep-dive](), [generics](), [go](), [go-compiler](), [go-concurrency](), [go-performance](), [go-runtime](), [golang](), [how-go-works](), [inside-go](), [internals](), [memory-management](), [performance](), [technology]() ### AI overview This article launches a technical series about how Go works internally. The planned installments cover compilation, memory management, garbage collection, concurrency, the runtime, performance tuning, interfaces, generics, modules, and reproducible builds, with code examples and runtime experiments. ### Source excerpt A deep-dive series into Go's internals. From compilation to memory management, concurrency, and performance tuning, each part unpacks how Go operates under the hood with clear explanations and real-life code examples. ## How we made JSON.stringify more than twice as fast DevFeed: [How we made JSON.stringify more than twice as fast]() Original publisher: [Read original article]() Author: Patrick Thier Published: 2025-08-04T00:00:00Z Content type: article Language: en Sources: [V8]() Topics: [modern web development](), [Web Development]() Tags: [ascii](), [data](), [internals](), [javascript](), [json](), [optimization](), [performance]() ### AI overview The article explains V8 optimizations that make JSON.stringify more than twice as fast. It covers a side-effect-free iterative fast path and specialized handling for one-byte and two-byte strings. ### Source excerpt JSON.stringify is a core JavaScript function for serializing data. Its performance directly affects common operations across the web, from serializing data for a network request to saving data to localStorage. A faster JSON.stringify translates to quicker page interactions and more responsive applications. That's why we're excited to share that a recent engineering effort has made JSON.stringify in V8 more than twice as fast. This post breaks down the technical optimizations that made this improvement possible. A Side-Effect-Free Fast Path # The foundation of this optimization is a new fast path built on a simple premise: if we can guarantee that serializing an object will not trigger any side effects, we can use a much faster, specialized implementation. A "side effect" in this context is anything that breaks the simple, streamlined traversal of an object. This includes not only the obvious cases like executing user-defined code during serialization, but also more subtle internal operations that might trigger a garbage collection cycle. For more details on what exactly can cause side effects and how you can avoid them, see Limitations. As long as V8 can determine that serialization will be free from these effects, it can stay on this highly-optimized path. This allows it to bypass many expensive checks and defensive logic required by the general-purpose serializer, resulting in a significant speedup for the most common types of JavaScript objects that represent plain data. Furthermore, the new fast path is iterative, in contrast to the recursive general-purpose serializer. This architectural choice not only eliminates the need for stack overflow checks and allows us to quickly resume after encoding changes, but also allows developers to serialize significantly deeper nested object graphs than was previously possible. Handling different String Representations # Strings in V8 can be represented with either one-byte or two-byte characters. If a string contains only AS ## Exploring PausableComposition internals in Jetpack Compose DevFeed: [Exploring PausableComposition internals in Jetpack Compose]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2025-07-14T05:34:31Z Content type: tutorial Language: en Sources: [Shreyas Patil's Blog]() Topics: [Compose](), [Jetpack Compose]() Tags: [android](), [android-app-development](), [code](), [compose](), [declarative](), [internals](), [jank](), [jetpack-compose](), [kotlin](), [kotlin-multiplatform](), [main-thread](), [performance](), [performance-optimization](), [ui](), [uiux]() ### AI overview This article explores the internals of PausableComposition, an internal API introduced in Compose 1.9.X. It explains how composition can be divided into smaller pieces and prepared asynchronously to reduce main-thread work and help prevent dropped frames during scrolling. ### Source excerpt Explore the internals of PausableComposition in Jetpack Compose. Learn how Compose manages state and effects when a composition is paused or resumed. ## Find the right mentor DevFeed: [Find the right mentor]() Original publisher: [Read original article]() Published: 2025-07-03T00:00:00Z Content type: opinion Language: en Sources: [Gaurav Sarma's Blog]() Topics: [Code](), [Python](), [C]() Tags: [c](), [career](), [experience](), [hashmap](), [internals](), [mentor](), [python](), [startup]() ### AI overview A personal account of learning from an experienced system programmer who challenged the author to understand Python data structures and their implementation details. The article recommends finding mentors who encourage deep technical understanding. ### Source excerpt Original Tweet - https://x. com/sarmag77/status/1952147743935521188 Something similar happened to me when I was working at a startup right out of college... ## New zine: The Secret Rules of the Terminal DevFeed: [New zine: The Secret Rules of the Terminal]() Original publisher: [Read original article]() Author: Julia Evans Published: 2025-06-26T00:00:00Z Content type: article Language: en Sources: [Julia Evans]() Topics: [Terminal](), [Shell](), [Command-line interface](), [Operating system](), [Software]() Tags: [blog](), [deep-dive](), [how-to](), [internals](), [software](), [terminal](), [tips-and-tricks]() ### AI overview The article announces a zine about the terminal and explains why terminal behavior can feel inconsistent or difficult to investigate. It introduces the terminal as a combination of a terminal emulator, operating system, shell, core utilities, and other programs, and presents the zine as a guide to their interactions, common conventions, and practical usage tips. ### Source excerpt Hello! After many months of writing deep dive blog posts about the terminal, on Tuesday I released a new zine called "The Secret Rules of the Terminal"! You can get it for $12 here: https://wizardzines.com/zines/terminal, or get an 15-pack of all my zines here. Here's the cover: the table of contents Here's the table of contents: why the terminal? I've been using the terminal every day for 20 years but even though I'm very confident in the terminal, I've always had a bit of an uneasy feeling about it. Usually things work fine, but sometimes something goes wrong and it just feels like investigating it is impossible, or at least like it would open up a huge can of worms. So I started trying to write down a list of weird problems I've run into in terminal and I realized that the terminal has a lot of tiny inconsistencies like: sometimes you can use the arrow keys to move around, but sometimes pressing the arrow keys just prints ^[[D sometimes you can use the mouse to select text, but sometimes you can't sometimes your commands get saved to a history when you run them, and sometimes they don't some shells let you use the up arrow to see the previous command, and some don't If you use the terminal daily for 10 or 20 years, even if you don't understand exactly why these things happen, you'll probably build an intuition for them. But having an intuition for them isn't the same as understanding why they happen. When writing this zine I actually had to do a lot of work to figure out exactly what was happening in the terminal to be able to talk about how to reason about it. the rules aren't written down anywhere It turns out that the "rules" for how the terminal works (how do you edit a command you type in? how do you quit a program? how do you fix your colours?) are extremely hard to fully understand, because "the terminal" is actually made of many different pieces of software (your terminal emulator, your operating system, your shell, the core utilities like grep, and every ## Speculative Optimizations for WebAssembly using Deopts and Inlining DevFeed: [Speculative Optimizations for WebAssembly using Deopts and Inlining]() Original publisher: [Read original article]() Author: Daniel Lehmann and Matthias Liedtke Published: 2025-06-24T00:00:00Z Content type: article Language: en Sources: [V8]() Topics: [WebAssembly](), [V8](), [JIT](), [Google Chrome](), [Compiler](), [JavaScript](), [Dart]() Tags: [benchmarks](), [code](), [compiler](), [dart](), [google-chrome](), [internals](), [javascript](), [jit](), [webassembly]() ### AI overview This V8 blog post describes speculative call_indirect inlining and deoptimization support for WebAssembly, shipped with Google Chrome M137. The optimizations use runtime feedback to generate better machine code, improving WebAssembly execution, especially for WasmGC programs. Dart microbenchmarks showed average speedups above 50%, while larger applications and benchmarks improved by 1% to 8%. ### Source excerpt In this blog post, we explain two optimizations for WebAssembly that we recently implemented in V8 and that shipped with Google Chrome M137, namely speculative call_indirect inlining and deoptimization support for WebAssembly. In combination, they allow us to generate better machine code by making assumptions based on runtime feedback. This speeds up WebAssembly execution, in particular for WasmGC programs. On a set of Dart microbenchmarks for example, the speedup by the combination of both optimizations is more than 50% on average, and on larger, realistic applications and benchmarks shown below the speedup is between 1% and 8%. Deoptimizations are also an important building block for further optimizations in the future. Background # Fast execution of JavaScript relies heavily on speculative optimizations. That is, JIT-compilers make assumptions when generating machine code based on feedback that was collected during earlier executions. For example, given the expression a + b, the compiler can generate machine code for an integer addition if past feedback indicates that a and b are integers (and not strings, floating point numbers, or other objects). Without making such assumptions, the compiler would have to emit generic code that handles the full behavior of the + operator in JavaScript, which is complex and thus much slower. If the program later behaves differently and thus violates assumptions made when generating the optimized code, V8 performs a deoptimization (or deopt, for short). That means throwing away the optimized code and continuing execution in unoptimized code (and collecting more feedback to possibly tier-up again later). In contrast to JavaScript, fast execution of WebAssembly hasn't required speculative optimizations and deopts. One reason is that WebAssembly programs can already be optimized quite well because more information is statically available as e.g., functions, instructions, and variables are all statically typed. Another reason is that ## Garbage Collection In Go : Part I - Semantics DevFeed: [Garbage Collection In Go : Part I - Semantics]() Original publisher: [Read original article]() Published: 2025-06-10T00:00:00Z Content type: tutorial Language: en Sources: [William Kennedy]() Topics: [Go Language](), [Programming language](), [Algorithm](), [Software]() Tags: [algorithm](), [ardan-labs](), [blog](), [garbage-collection](), [go](), [go-programming](), [golang](), [guide](), [internals](), [memory](), [performance](), [programming]() ### AI overview This tutorial explains the semantics of Go's garbage collector, including heap allocation tracking, concurrent tri-color mark-and-sweep collection, and Stop The World events. It presents a behavioral model intended to remain useful despite changes to runtime implementation details. ### Source excerpt This article was originally published in 2018, yet its core insights into Go's garbage collection model remain highly relevant for developers today. While some implementation details of Go's runtime have evolved, the foundational concepts explored here--such as the semantics of the tri-color mark and sweep algorithm, Stop The World (STW) events, and GC trace interpretation--are still essential to understanding how Go manages memory. Whether you're optimizing performance or deepening your knowledge of Go internals, this post continues to offer a clear and practical guide to working with the garbage collector, not against it. ## Land ahoy: leaving the Sea of Nodes DevFeed: [Land ahoy: leaving the Sea of Nodes]() Original publisher: [Read original article]() Author: Darius Mercadier Published: 2025-03-25T00:00:00Z Content type: article Language: en Sources: [V8]() Topics: [Compiler](), [V8](), [JavaScript](), [WebAssembly](), [Graphs]() Tags: [architectures](), [asm](), [blog-post](), [compiler](), [internals](), [javascript](), [performance](), [technical](), [webassembly]() ### AI overview This V8 developer article explains the project's move away from the Sea of Nodes intermediate representation toward the more traditional Control-Flow Graph representation used by Turboshaft. It describes the migration status across the JavaScript and WebAssembly compiler pipelines and introduces the historical limitations and technical debt associated with Crankshaft. ### Source excerpt V8's end-tier optimizing compiler, Turbofan, is famously one of the few large-scale production compilers to use Sea of Nodes (SoN). However, since almost 3 years ago, we've started to get rid of Sea of Nodes and fall back to a more traditional Control-Flow Graph (CFG) Intermediate Representation (IR), which we named Turboshaft. By now, the whole JavaScript backend of Turbofan uses Turboshaft instead, and WebAssembly uses Turboshaft throughout its whole pipeline. Two parts of Turbofan still use some Sea of Nodes: the builtin pipeline, which we're slowly replacing by Turboshaft, and the frontend of the JavaScript pipeline, which we're replacing by Maglev, another CFG-based IR. This blog post explains the reasons that led us to move away from Sea of Nodes. The birth of Turbofan and Sea of Nodes # 12 years ago, in 2013, V8 had a single optimizing compiler: Crankshaft. It was using a Control-Flow Graph based Intermediate Representation. The initial version of Crankshaft provided significant performance improvements despite still being quite limited in what it supported. Over the next few years, the team kept improving it to generate even faster code in ever more situations. However, technical debt was starting to stack up and a number of issues were arising with Crankshaft: It contained too much hand-written assembly code. Every time a new operator was added to the IR, its translation to assembly had to be manually written for the four architectures officially supported by V8 (x64, ia32, arm, arm64). It struggled with optimizing asm.js, which was back then seen as an important step towards high-performance JavaScript. It didn't allow introducing control flow in lowerings. Put otherwise, control flow was created at graph building time, and was then final. This was a major limitation, given that a common thing to do when writing compilers is to start with high-level operations, and then lower them to low-level operations, often by introducing additional control flow. Consi ## Turbocharging V8 with mutable heap numbers DevFeed: [Turbocharging V8 with mutable heap numbers]() Original publisher: [Read original article]() Author: Victor Gomes, the bit shifter Published: 2025-02-25T00:00:00Z Content type: article Language: en Sources: [V8]() Topics: [Code]() Tags: [benchmark](), [benchmarks](), [internals](), [javascript](), [optimization](), [performance](), [random]() ### AI overview This article explains a V8 optimization for mutable heap numbers that improves JavaScript performance in the JetStream2 async-fs benchmark by reducing allocation pressure and enabling faster integer arithmetic. ### Source excerpt At V8, we're constantly striving to improve JavaScript performance. As part of this effort, we recently revisited the JetStream2 benchmark suite to eliminate performance cliffs. This post details a specific optimization we made that yielded a significant 2.5x improvement in the async-fs benchmark, contributing to a noticeable boost in the overall score. The optimization was inspired by the benchmark, but such patterns do appear in real-world code. The target async-fs and a peculiar Math.random # The async-fs benchmark, as its name suggests, is a JavaScript file system implementation, focusing on asynchronous operations. However, a surprising performance bottleneck exists: the implementation of Math.random. It uses a custom, deterministic implementation of Math.random for consistent results across runs. The implementation is: let seed; Math.random = (function() { return function () { seed = ((seed + 0x7ed55d16) + (seed << 12)) & 0xffffffff; seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff; seed = ((seed + 0x165667b1) + (seed << 5)) & 0xffffffff; seed = ((seed + 0xd3a2646c) ^ (seed << 9)) & 0xffffffff; seed = ((seed + 0xfd7046c5) + (seed << 3)) & 0xffffffff; seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff; return (seed & 0xfffffff) / 0x10000000; }; })(); The key variable here is seed. It's updated on every call to Math.random, generating the pseudo-random sequence. Crucially, here seed is stored in a ScriptContext. A ScriptContext serves as a storage location for values accessible within a particular script. Internally, this context is represented as an array of V8's tagged values. On the default V8 configuration for 64-bit systems, each of these tagged values occupies 32 bits. The least significant bit of each value acts as a tag. A 0 indicates a 31-bit Small Integer (SMI). The actual integer value is stored directly, left-shifted by one bit. A 1 indicates a compressed pointer to a heap object, where the compressed pointer value is incremented by o ## Inserting One New Element into Hashes of Varying Sizes DevFeed: [Inserting One New Element into Hashes of Varying Sizes]() Original publisher: [Read original article]() Author: Pat Shaughnessy Published: 2025-02-04T00:00:00Z Content type: tutorial Language: en Sources: [Pat Shaughnessy]() Topics: [Ruby](), [hash](), [Benchmark](), [Code]() Tags: [benchmark](), [hash](), [internals](), [ruby](), [table](), [updating-ruby-under-a-microscope]() ### AI overview This article presents a Ruby experiment measuring the time required to insert one new element into hashes of different sizes. Using Ruby 3.4.1, it observes timing spikes when the hash grows to certain sizes, consistent with rehashing or redistribution. ### Source excerpt I've started working on a new edition of Ruby Under a Microscope that covers Ruby 3.x. I'm working on this in my spare time, so it will take a while. Leave a comment or drop me a line and I'll email you when it's finished. RUM includes a serie ## Updating Ruby Under a Microscope DevFeed: [Updating Ruby Under a Microscope]() Original publisher: [Read original article]() Author: Pat Shaughnessy Published: 2025-01-28T00:00:00Z Content type: article Language: en Sources: [Pat Shaughnessy]() Topics: [Ruby](), [hash](), [Computer science](), [C]() Tags: [hash](), [internals](), [ruby](), [updating](), [updating-ruby-under-a-microscope]() ### AI overview An excerpt from a planned new edition of Ruby Under a Microscope explains how Ruby uses hash tables internally. It introduces hash-table organization and describes how Ruby stores keys, values, entries, bins, and related C structures. ### Source excerpt Ruby stores much of its own internal data in hash tables. I've started working on a new edition of ## Snapshot Isolation vs Serializability DevFeed: [Snapshot Isolation vs Serializability]() Original publisher: [Read original article]() Author: Marc Brooker Published: 2024-12-17T00:00:00Z Content type: article Language: en Sources: [Marc Brooker's Blog](), [Marc Brooker's Blog]() Topics: [DSQL](), [Transactions](), [Databases](), [SQL](), [systems]() Tags: [database](), [dsql](), [fundamentals](), [internals](), [sql](), [transactions]() ### AI overview This article examines snapshot isolation and serializability in database systems, using read-write and write-write conflicts to explain transaction behavior. It focuses on write skew, read sets, write sets, and the trade-offs among SQL isolation levels, with Aurora DSQL providing the motivating context. ### Source excerpt Snapshot Isolation vs Serializability Getting into some fundamentals. In my re:Invent talk on the internals of Aurora DSQL I mentioned that I think snapshot isolation is a sweet spot in the database isolation spectrum for most kinds of applications. Today, I want to dive in a little deeper into why I think that, and some of the trade-offs of going stronger and weaker. This post is going to be a little deeper than the last few. If you're not deeply familiar with SQL's isolation levels, I recommend checking out Crooks et al's Seeing is Believing: A Client-Centric Specification of Database Isolation, Berenson et al's A Critique of ANSI SQL Isolation Levels, or Adya et al's Generalized Isolation Level Definitions. Specifically, I'm going to talk about one very specific mental model of transaction isolation: read-write conflicts, and write-write conflicts. Let's start our journey with a transaction, T1: BEGIN; SELECT amnt FROM food WHERE id = 1 OR id = 2; UPDATE food SET amnt = amnt - 1 WHERE id = 1; COMMIT; There are a few things to notice about this transaction, when run in a database system that offers interactive (i.e. back-and-forth with the client) transactions: It directly reads two rows from the database, the rows 1 and 2 from the table food. It directly writes one row in the database, the rows 1 from the table food. It starts and ends at different times: starting during BEGIN and ending during COMMIT. Depending on the way that database is implemented, it also likely reads other data (e.g. the system catalog which tells it which tables exist), and may write other data (e.g. a secondary index on the amnt column of food). The forth point here is critical in real systems, but let's ignore it for now and focus only on the first three2. Before we do that, let's introduce a second transaction, the first one's parallel universe clone, T2. We'll also assume these are the only transactions running at this time. BEGIN; SELECT amnt FROM food WHERE id = 1 OR id = 2; UPDATE f [Next page]()