<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Compilers on miti99</title><link>https://miti99.com/en/tags/compilers/</link><description>Recent content in Compilers on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/compilers/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #72</title><link>https://miti99.com/en/post/2025/12/15/</link><pubDate>Mon, 15 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/15/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #72.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-easiest-way-to-build-a-type-checker"&gt;&lt;a href="https://jimmyhmiller.com/easiest-way-to-build-type-checker" rel="noopener noreferrer"&gt;The Easiest Way to Build a Type Checker&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller shares that papers and tutorials on Hindley-Milner or Algorithm W never helped him understand how a type checker is actually implemented—until he discovered bidirectional type checking. The core idea is to split the work into two directions: &lt;code&gt;infer&lt;/code&gt; deduces the type of an expression, while &lt;code&gt;check&lt;/code&gt; verifies whether an expression matches an expected type. In exchange for this simplicity, the language requires a few type annotations, usually just on function definitions, while local variables are still inferred automatically. He presents a roughly 100-line TypeScript implementation for a small language with numbers, strings, functions, function calls, &lt;code&gt;let&lt;/code&gt; bindings, and blocks.&lt;/p&gt;
&lt;p&gt;The post walks through each component: an abstract syntax tree (AST) makes traversing a program much easier than working with raw strings, and the type context is just a &lt;code&gt;Map&lt;/code&gt; from variable names to types that gets cloned whenever entering a new function or block scope. By adding addition as an example, he shows how &lt;code&gt;infer&lt;/code&gt; and &lt;code&gt;check&lt;/code&gt; mutually recurse until they bottom out at base cases. While this type checker is far from complete, it serves as an approachable starting point to extend and understand type systems without wading through dense academic papers.&lt;/p&gt;
&lt;h2 id="deprecation"&gt;&lt;a href="https://abseil.io/resources/swe-book/html/ch15.html" rel="noopener noreferrer"&gt;Deprecation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Chapter 15 of &lt;em&gt;Software Engineering at Google&lt;/em&gt;, which focuses on the planned deprecation and removal of obsolete systems. The chapter&amp;rsquo;s premise is that &amp;ldquo;code is a liability, not an asset&amp;rdquo;: every system carries ongoing operational and maintenance costs, so once an equivalent replacement exists, running both in parallel increases complexity and holds back the new system. Even so, age alone is not a reason to deprecate, and an organization should only take on as many deprecation efforts as it can realistically finish, committing to see them through to the end.&lt;/p&gt;
&lt;p&gt;The authors explain why deprecation is so hard: Hyrum&amp;rsquo;s Law means users come to depend on unpromised behaviors, a new system rarely achieves 100% parity with the old one, engineers form emotional attachments to code they wrote, and securing resources for cleanup work is a tough sell. Google distinguishes between advisory deprecation and compulsory deprecation with enforced deadlines, emphasizing clear ownership, milestones, migration support, and tooling like static analysis and large-scale changes to block new usages. Key takeaways for engineers include designing systems with replaceable parts from the start and favoring incremental in-place evolution over full rewrites.&lt;/p&gt;
&lt;h2 id="16-replication-concepts-every-software-engineer-should-know-simple-guide-for-2026"&gt;&lt;a href="https://designgurus.substack.com/p/16-replication-concepts-every-software" rel="noopener noreferrer"&gt;16 Replication Concepts Every Software Engineer Should Know (Simple Guide for 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arslan Ahmad explains sixteen data replication concepts that keep large-scale systems reliable, fast, and fault-tolerant, pairing each concept with a practical example. The post begins with the three main topologies: single-leader replication where one node accepts all writes, multi-leader replication suited for multi-region applications at the cost of conflict resolution, and leaderless replication (like Dynamo) where any node can accept writes. Next come synchronous, asynchronous, and semi-synchronous replication modes, illustrating the trade-off between durability and latency—for instance, a bank waiting for replicas to confirm a transaction versus a social network accepting a few seconds of delay before a photo appears in another region.&lt;/p&gt;
&lt;p&gt;Later sections cover read and write quorums (such as requiring three out of five replicas to acknowledge), replication lag and the risk of stale reads, failover when a primary node goes down, geo-replication, and self-healing mechanisms like read repair and hinted handoff. It serves as a concise primer for engineers looking to understand what happens under the hood of the distributed databases they use every day.&lt;/p&gt;
&lt;h2 id="50-system-design-concepts-for-beginners-in-90-minutes-"&gt;&lt;a href="https://designgurus.substack.com/p/50-system-design-concepts-for-beginners" rel="noopener noreferrer"&gt;50 System Design Concepts for Beginners in 90 Minutes [2026 Edition]&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arslan Ahmad rounds up 50 essential system design concepts in a single guide aimed at beginners and interview candidates, explaining each concisely with an intuitive example. The fundamentals section covers vertical vs. horizontal scaling, the CAP and PACELC theorems, ACID vs. BASE, throughput vs. latency, Amdahl&amp;rsquo;s Law, strong vs. eventual consistency, stateful vs. stateless architectures, and choosing between monoliths, microservices, and serverless.&lt;/p&gt;
&lt;p&gt;Subsequent sections walk through networking and communication (load balancing, CDNs, gRPC vs. REST), data storage (sharding, replication, indexing), reliability patterns like circuit breakers, retries, and idempotency, caching strategies, message queues, observability with tracing and SLIs/SLOs, and security with OAuth, TLS, and Zero Trust. The recurring theme is that no option is universally best: a system designer must understand the trade-offs of each approach to pick the right fit for the problem at hand—for example, starting with a monolith and only splitting into microservices when truly necessary.&lt;/p&gt;
&lt;h2 id="ddd-a-toolbox-not-a-religion"&gt;&lt;a href="https://threedots.tech/episode/ddd-toolbox-not-religion" rel="noopener noreferrer"&gt;DDD: A Toolbox, Not a Religion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of the &lt;em&gt;No Silver Bullet&lt;/em&gt; podcast, Miłosz and Robert from Three Dots Labs discuss why software projects often start out promising and gradually turn into legacy code nobody wants to touch: new features diverge from the original design, and instead of remodeling, teams just pile on quick patches time after time. In their view, most projects fail not because of technical challenges, but because of poorly handled business complexity—most SaaS apps use very similar tech stacks, and what actually differentiates companies is the domain they serve.&lt;/p&gt;
&lt;p&gt;The hosts treat Domain-Driven Design (DDD) as a toolbox rather than a religion: you don&amp;rsquo;t need to apply every pattern, just pick what solves your actual problem. They warn against solving imaginary problems, like spending months building a custom framework or platform before shipping real features, sharing an anecdote about a generic messaging framework that kept them from ever finishing a game jam entry. Their advice is to understand the business model before designing database schemas, and to always apply strategic patterns—like identifying the core domain and module boundaries—even when skipping tactical patterns. As Miłosz sums it up: &amp;ldquo;DDD is about understanding the domain you work in and then modeling it well in code.&amp;rdquo;&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!lwoL!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb1ec5785-ad8a-4350-b07d-005f7b04b1f1_2250x2624.png" alt="Saga Pattern Demystified: Orchestration vs Choreography"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SfCa!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F55ac4874-04fc-4ea7-a083-bde8f6f99cf5_2360x2960.png" alt="Virtualization vs. Containerization"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!zlUS!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F156acc80-7588-4fc1-8f43-7fa1458d646c_2360x2770.png" alt="5 REST API Authentication Methods"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!CYiE!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F5eb76d35-fba8-48de-84d1-228060740d89_2360x2960.png" alt="What is a Firewall?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!fKIx!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7278af0a-b8cb-4b72-bd48-341e92286b1b_2360x2960.png" alt="Modem vs. Router"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!zdVq!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F60a16dc3-e973-4d2d-a0c2-7d426d5fe6c9_2250x2624.png" alt="A Guide to Service Mesh Architectural Pattern"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Q7Mr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F73400113-5bd5-4c40-a7e3-7346fb229256_3000x3900.jpeg" alt="What is a REST API?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Phtx!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa7dce573-ac95-46cc-a80d-62f80e6f0602_800x989.jpeg" alt="How Java HashMaps Work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!1-F-!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F473c684e-3c14-44c1-9889-97fef9caef15_2360x2960.png" alt="Virtualization Explained: From Bare Metal to Hosted Hypervisors"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!yDvA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa3c9b76d-b1b9-4284-a64e-16faa832544e_2250x2624.png" alt="Must-Know System Performance Strategies"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!_5Is!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F6ebf5287-65fa-4db7-8490-54792fd1886c_2360x2920.png" alt="Apache Kafka vs. RabbitMQ"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!1Hk2!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fced11d9e-ce25-439e-9a56-4ccf37c1854f_2360x2770.png" alt="The HTTP Mindmap"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!hn6T!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa0f70b08-6fa9-4413-9bd4-0571f99dba60_2360x2664.png" alt="How DNS Works"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Sny4!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7911abd9-06ce-48f4-98c5-c3305b752fb7_800x1142.jpeg" alt="Can a web server provide real-time updates?"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Videos:&lt;/strong&gt;
&lt;a href="https://www.youtube.com/watch?v=HHUi8F_qAXM" rel="noopener noreferrer"&gt;How Does a URL Shortener Work?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #61</title><link>https://miti99.com/en/post/2025/11/25/</link><pubDate>Tue, 25 Nov 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/11/25/</guid><description>&lt;p&gt;&lt;em&gt;Been &amp;lsquo;offline&amp;rsquo; for quite a while, finally resurfacing today. Enjoy Newsletter #61.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="beyond-indexes-how-open-table-formats-optimize-query-performance"&gt;&lt;a href="https://jack-vanlightly.com/blog/2025/10/8/beyond-indexes-how-open-table-formats-optimize-query-performance/" rel="noopener noreferrer"&gt;Beyond Indexes: How Open Table Formats Optimize Query Performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jack Vanlightly, who previously worked on SQL Server performance tuning and now specializes in data systems, pushes back against the idea that open table formats (OTFs) like Apache Iceberg or Delta Lake should add secondary indexes like relational databases. In an OLTP RDBMS, B-tree clustered indexes and secondary indexes quickly locate one or a few rows in exchange for higher write overhead. Analytical queries are fundamentally different: they scan millions of rows of immutable, columnar data stored on object storage like S3, so chasing secondary-index pointers offers almost no benefit.&lt;/p&gt;
&lt;p&gt;Instead, OTFs speed up queries through data skipping: pruning entire irrelevant files before reading them. Data skipping relies on physical layout (partitioning, sorting, compaction), min/max statistics in manifests and data files, and file- or row-group-level Bloom filters where supported, alongside complementary tools like materialized views. The author sums it up as &amp;ldquo;layout is king&amp;rdquo;: performance comes from organizing data so partitions match filter predicates and similar values sit close together. Materialized views are the closest equivalent to a secondary index, and the path forward is letting query engines build their own optimizations on top of standard table specs rather than cramming complex index structures into the OTF specification itself.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://den.dev/blog/github-spec-kit/" rel="noopener noreferrer"&gt;What&amp;rsquo;s The Deal With GitHub Spec Kit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Den Delimarsky observes that while LLMs are useful for coding, their output varies wildly: for the same requirement, different prompts produce very different code. His proposed solution is Spec-Driven Development (SDD), where a specification clearly defines the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;why&amp;rdquo; of a feature while deliberately leaving out technical implementation details. GitHub Spec Kit is an experimental open-source toolkit that puts this workflow into practice through a sequence of slash commands: &lt;code&gt;/constitution&lt;/code&gt; sets core principles, &lt;code&gt;/specify&lt;/code&gt; writes the spec, &lt;code&gt;/clarify&lt;/code&gt; resolves ambiguities, &lt;code&gt;/plan&lt;/code&gt; creates the technical plan, &lt;code&gt;/tasks&lt;/code&gt; breaks down the work, and &lt;code&gt;/analyze&lt;/code&gt; checks consistency before implementation.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, an LLM is like an over-eager junior engineer who needs clear requirements and guidance. With SDD, the specification becomes an executable document while the source code becomes disposable—something that can be regenerated and verified on demand; decoupling the spec from a specific tech stack also makes it easy to compare multiple implementations. He illustrates this by building a tool that aggregates webcam images from Mauna Kea in under two hours, while stressing that specs are no silver bullet: humans still have to supervise and iterate continually. As models grow more capable, the bottleneck shifts to accurately communicating developer intent, and a solid spec is how you solve it.&lt;/p&gt;
&lt;h2 id="just-talk-to-it---the-no-bs-way-of-agentic-engineering"&gt;&lt;a href="https://steipete.me/posts/just-talk-to-it" rel="noopener noreferrer"&gt;Just Talk To It - the no-bs Way of Agentic Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Steinberger shares his agentic engineering workflow for projects where nearly all the code is written by AI. His central message is &amp;ldquo;just talk to it&amp;rdquo;: instead of chasing elaborate frameworks, work directly with a capable model, use it enough to build intuition, and keep your workflow dead simple. He prefers &lt;code&gt;GPT-5-Codex&lt;/code&gt; over Claude Code because it uses context more efficiently, runs faster, supports message queueing, and reads more files before acting. His prompts are often just one or two sentences paired with a screenshot pointing out what needs fixing. A key concept is &amp;ldquo;blast radius&amp;rdquo;: estimating how many files a change will touch so you can slice work sensibly, run multiple agents in parallel across terminal panes, and commit in small increments.&lt;/p&gt;
&lt;p&gt;He favors CLIs over MCPs to avoid wasting context, writes tests right after each feature in the same session, and spends roughly 20% of his time having the agent refactor code. Conversely, RAG, subagents, &amp;ldquo;plan mode,&amp;rdquo; and convoluted agent instructions aren&amp;rsquo;t worth much in his experience. His toolkit consists of Codex CLI, Wispr Flow for voice input, &lt;code&gt;tmux&lt;/code&gt; for background tasks, and &lt;code&gt;ast-grep&lt;/code&gt; for code checks, backed by an ~800-line &lt;code&gt;Agents.md&lt;/code&gt; file. His takeaway: building great software is still hard, the required skillset resembles managing senior engineers, and the bar for architecture and user experience is higher than ever.&lt;/p&gt;
&lt;h2 id="jit-so-you-want-to-be-faster-than-an-interpreter-on-modern-cpus"&gt;&lt;a href="https://www.pinaraf.info/2025/10/jit-so-you-want-to-be-faster-than-an-interpreter-on-modern-cpus/" rel="noopener noreferrer"&gt;JIT: so you want to be faster than an interpreter on modern CPUs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinaraf, who is developing a JIT compiler for PostgreSQL, explains why a JIT isn&amp;rsquo;t automatically faster than an interpreter on modern CPUs. Today&amp;rsquo;s CPUs are superscalar, out-of-order machines with sophisticated branch predictors capable of executing multiple instructions in parallel and hiding latency remarkably well. Traditional interpreters use a &lt;code&gt;switch&lt;/code&gt; statement to dispatch opcodes, creating hard-to-predict branches; PostgreSQL replaces this with computed gotos that jump directly to each opcode handler, allowing the CPU to predict branches much more accurately. As a result, a well-written interpreter is surprisingly competitive with compiled code.&lt;/p&gt;
&lt;p&gt;The author analyzes the query &lt;code&gt;SELECT a FROM table WHERE a = 42&lt;/code&gt; over a 10-million-row table, which compiles into an opcode sequence of &lt;code&gt;SCAN_FETCHSOME&lt;/code&gt;, &lt;code&gt;SCAN_VAR&lt;/code&gt;, &lt;code&gt;FUNCEXPR_STRICT_2&lt;/code&gt; (null checks followed by &lt;code&gt;int4eq&lt;/code&gt;), &lt;code&gt;QUAL&lt;/code&gt;, and &lt;code&gt;DONE_RETURN&lt;/code&gt;. Removing redundant null checks on constants yields a 7.9% speedup, dropping all null checks gives 9.5%, inlining &lt;code&gt;int4eq&lt;/code&gt; reaches 10.3%, and his experimental JIT achieves 23%—cutting instructions by 11%, cycles by 20%, and branches by 13%. Notably, those first optimizations apply just as well to the interpreter as to the JIT, narrowing the JIT&amp;rsquo;s traditional edge; truly beating the interpreter requires deeper optimizations that the author promises to cover in follow-up posts.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;For this post I used CCR with the &lt;code&gt;x-ai/grok-4.1-fast:free&lt;/code&gt; model. It doesn&amp;rsquo;t seem great yet—a lot of rough untranslated English remained. I&amp;rsquo;ll try to improve it further.&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>