Building a Statically-Typed Language from Scratch in C++17

You can think of agentic engineering as just another compiler layer, which sits on top of your C++ compiler, which sits on top of LLVM, etc... But the analogy breaks down, because prompts are ephemeral, and don't stick as the literate description (in Don Knuth's sense of "literate programming") of the code. The main reason is that your "compiler," the LLM, is neither hermetic nor deterministic. I do wonder if we're in a wrong local optimum of vibe coding as a result: imagine a world in which you check in your prompts as the source of truth, and the resulting code is what's ephemeral, or a blend of both like in CWEB. This would bring some rigor and sharing capabilities to the exercise of prompting agents, and elevate the entire codebase by one abstraction layer. Another big challenge is that the results of a prompt are non-local, and as a consequence, using them as a linear description of the code is not particularly useful: it's more like a version tree. It is be super interesting to think about what a prompting-aware 'git' would look like, and the role of comments vs. prompts in this environment.

Vincent Vanhoucke asks the right question in his post: what happens to engineering rigour when your compiler (+ LLM) is neither hermetic nor deterministic? Intent as Source: 1. Code remains the source of truth: Prompts are scaffolding, not artifacts. The durable value lives in explicitly recorded decisions made under constraint - including what was rejected and why. 2. Treat the LLM as a versioned dependency: Pin the model, lock the environment, manage inputs. Rigour comes from dependency discipline, not from chasing determinism you'll never fully achieve. 3. Treat agentic sessions as design exploration, not just execution: AI accelerates discovery and expands the solution space - the goal is capability amplification, not just risk mitigation. That value is lost if you reduce sessions to a compliance exercise. 4. Capture decisions, not dialogues - and capture sparingly: Raw prompt logs are noise. What matters is a distilled, human-validated rationale for irreversible architectural choices. Over-capture recreates the specification-bloat failure modes that killed waterfall (don't repeat that mistake). 5. Link rationale to the commit, not to a new system: Attach session summaries and decision notes to standard Git commit hashes. You get governance, continuity, and auditability without inventing infrastructure that doesn't exist yet. 6. Position humans at the boundaries that matter, and extend - don't replace - existing engineering norms: Human judgment adds value when defining constraints, validating pivots, and approving rationale. AI-native development should build on code-as-truth and disciplined commits, not resurrect specification-first paradigms that collapsed under their own weight. https://lnkd.in/eD3jdXpY

Sometimes, the level of detail that is considered in programming is insane. For a long time, I knew that if you want to build a shared library in C/C++, you usually compile with the -fPIC flag, but I never really stopped to think about what it actually does. So I did a little bit of digging, and wanted to share my understanding here. -fPIC stands for Position Independent Code. It tells the compiler to generate machine code that can run correctly regardless of where it ends up in memory. This matters because shared libraries are loaded dynamically by the operating system. Their final memory address isn’t known when the code is compiled. On top of that, modern systems use ASLR (Address Space Layout Randomization), which intentionally loads programs and libraries at different memory addresses each time they run for security reasons. If the compiled code relied on fixed memory addresses, the library would break as soon as it was loaded somewhere else. Position-independent code avoids this by not using absolute addresses. Instead, the generated instructions reference data and functions relative to the current instruction location. Under the hood, this is implemented through structures like the Global Offset Table (GOT) and the Procedure Linkage Table (PLT), which help resolve addresses at runtime. So when we write something like: gcc source.c -shared -fPIC -o libexample.so We’re basically telling the compiler: generate code that can safely live anywhere in memory, because this binary will be used as a shared library. It’s one of those flags that you use almost automatically. But when you look into it, you realize there’s a surprisingly elegant idea behind it. Here is a link for further information on GOT, PLT, and how they would handle addresses during runtime: https://lnkd.in/gGFyaUxE #cplusplus #c++ #programming

For years, I have been building software and systems using languages like Go, Rust, C/C++, Java, and JS. Working across so many different ecosystems teaches you a lot. You start to see exactly what makes a language a joy to use, and what creates unnecessary cognitive load. A few months ago, I decided to do something I had never done before: write my own systems programming language from scratch. It is called Vex. This is my first time designing a language and building a compiler. My goal was to combine the bare-metal control of C/C++, the memory safety of Rust, and the clean, atomic developer experience of Go. Instead of forcing developers to fight with a borrow checker or manage manual memory allocations, I wanted to see if the compiler could handle it autonomously. By analyzing the lifecycle of the code, Vex decides the optimal memory strategy under the hood, allowing you to focus purely on strict typing and clean architecture. It has been a massive learning curve. Vex is definitely not production-ready yet, but the core compiler, the LSP, and the testing pipeline are actually working. I wrote an article on Medium about this entire journey, the architectural decisions, and why I believe we need compilers that truly understand our code. If you are interested in language design, systems programming, or just building things from scratch, I would love to hear your thoughts. Website: https://vex-lang.org Read the full article:https://lnkd.in/dsCeWYDj

🚀 Building a Low-Level Kernel Code Generator for Straw One of the most interesting parts of building Straw, my custom systems programming language, has been designing the compiler backend that generates low-level kernel assembly. Instead of only compiling simple programs, I experimented with generating boot-level assembly code that interacts directly with hardware. This includes things like: • CPU initialization • Interrupt disabling • Stack setup • Global Descriptor Table (GDT) configuration • Direct VGA memory output A simplified part of the Straw compiler backend looks like this: use crate::ir::IRNode; pub struct KernelCodeGenerator; impl KernelCodeGenerator { pub fn generate(ir: &[IRNode]) -> String { let mut asm = String::new(); asm.push_str(&Self::boot_header()); asm.push_str(&Self::text_section(ir)); asm.push_str(&Self::data_section()); asm.push_str(&Self::bss_section()); asm.push_str(&Self::gdt_section()); asm } } This backend converts the Intermediate Representation (IR) produced by the compiler into x86 assembly instructions used for kernel-level execution. Example of the generated assembly structure: _start: cli mov esp, stack_top call setup_segments call kernel_main This process helped me explore several core low-level concepts: • Compiler backend architecture • Instruction-level code generation • Memory and stack initialization • CPU segmentation setup • Kernel bootstrap design Projects like this make it possible to understand the entire path from programming language → machine code → operating system execution. Still improving the Straw language ecosystem and compiler architecture. 🚀 The journey into low-level systems programming continues. #SystemsProgramming #CompilerDesign #OperatingSystems #LowLevelProgramming #Rust #KernelDevelopment

𝗚𝗼𝗶𝗻𝗴 𝗟𝗶𝘃𝗲: 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗖𝗼𝗺𝗽𝗶𝗹𝗲𝗿𝘀 𝗳𝗿𝗼𝗺 𝗙𝗶𝗿𝘀𝘁 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 [𝗗𝗮𝘁𝗲: 𝟴 𝗠𝗮𝗿𝗰𝗵 𝟮𝟬𝟮𝟲] ----------------------------------------------------------- Every programmer writes code. But very few truly understand what happens after you press compile. 𝘏𝘰𝘸 𝘥𝘰𝘦𝘴 𝘺𝘰𝘶𝘳 𝘤𝘰𝘥𝘦 𝘵𝘳𝘢𝘯𝘴𝘧𝘰𝘳𝘮 𝘧𝘳𝘰𝘮 𝘩𝘪𝘨𝘩-𝘭𝘦𝘷𝘦𝘭 𝘴𝘰𝘶𝘳𝘤𝘦 𝘤𝘰𝘥𝘦 𝘪𝘯𝘵𝘰 𝘮𝘢𝘤𝘩𝘪𝘯𝘦 𝘪𝘯𝘴𝘵𝘳𝘶𝘤𝘵𝘪𝘰𝘯𝘴 𝘵𝘩𝘢𝘵 𝘢 𝘊𝘗𝘜 𝘰𝘳 𝘎𝘗𝘜 𝘤𝘢𝘯 𝘦𝘹𝘦𝘤𝘶𝘵𝘦? In this 𝗖𝗼𝗺𝗽𝗶𝗹𝗲𝗿𝗦𝘂𝘁𝗿𝗮 𝗹𝗶𝘃𝗲 𝘀𝗲𝘀𝘀𝗶𝗼𝗻, we will break down the entire compiler pipeline simply and practically. 📖 The discussion will be mostly based on this article: https://lnkd.in/guD7EsaH 🎥 Join the live session here: https://lnkd.in/gDKXCUYA In this session, we will explore: 🔹 What a compiler actually does 🔹 The journey from Source Code → Tokens → AST → IR → Machine Code 🔹 Core compiler stages: • Lexical Analysis • Parsing • Semantic Analysis • Intermediate Representation (IR) • Optimization • Code Generation If you want to move beyond just writing code and start understanding how code actually runs, this session will give you the right foundation. Join the discussion and feel free to ask questions live. #Compilers #CompilerDesign #LLVM #MLIR #SystemsProgramming #LowLevelProgramming #ProgrammingLanguages #ComputerArchitecture #GPU #CompilerSutra

Ever get an "𝐮𝐧𝐝𝐞𝐟𝐢𝐧𝐞𝐝 𝐫𝐞𝐟𝐞𝐫𝐞𝐧𝐜𝐞" error, even though you 𝐤𝐧𝐨𝐰 the function exists? The culprit is usually 𝐍𝐚𝐦𝐞 𝐌𝐚𝐧𝐠𝐥𝐢𝐧𝐠. 𝐓𝐡𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: C++ supports function overloading, so the compiler renames your functions to be unique. Your code: 𝐯𝐨𝐢𝐝 𝐫𝐮𝐧() What the compiler creates: _𝐙𝟑𝐫𝐮𝐧𝐯 C doesn’t support this, so it keeps the name simple: 𝐫𝐮𝐧. When the linker looks for _𝐙𝟑𝐫𝐮𝐧𝐯 in a C library that only has 𝐫𝐮𝐧, it fails. 𝐓𝐡𝐞 𝐅𝐢𝐱: 𝐞𝐱𝐭𝐞𝐫𝐧 "𝐂" 𝐞𝐱𝐭𝐞𝐫𝐧 "𝐂" is like a "𝐭𝐫𝐚𝐧𝐬𝐥𝐚𝐭𝐨𝐫" for your compiler. It tells C++: "𝐇𝐞𝐲, 𝐝𝐨𝐧'𝐭 𝐫𝐞𝐧𝐚𝐦𝐞 𝐭𝐡𝐢𝐬 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧. 𝐊𝐞𝐞𝐩 𝐢𝐭 𝐬𝐢𝐦𝐩𝐥𝐞 𝐬𝐨 𝐭𝐡𝐞 𝐂 𝐥𝐢𝐧𝐤𝐞𝐫 𝐜𝐚𝐧 𝐟𝐢𝐧𝐝 𝐢𝐭." 𝐒𝐡𝐨𝐫𝐭: If you’re mixing C and C++ code, wrap your C declarations in 𝐞𝐱𝐭𝐞𝐫𝐧 "𝐂" { ... }. It saves hours of debugging time! #CodingTips #CPP #SoftwareEngineering #Programming #TechSimplified #C++ #C

Ever wondered what actually happens behind a simple printf("Hello World");? 🚀 Most of us start our journey with C, but we often take the compilation process for granted. Understanding the Life Cycle of a .c file is the difference between just "writing code" and truly understanding how systems work. I just published a new technical deep dive exploring the 4 critical stages: 1️⃣ Preprocessor (cpp): Handling headers and macros. 2️⃣ Compiler (cc1): Translating code to Assembly. 3️⃣ Assembler (as): Converting to machine-level object files. 4️⃣ Linker (ld): Merging it all into a final executable. Knowing this flow is essential for anyone looking to write optimized, high-performance code. Check out the full breakdown on my blog: 🔗 https://lnkd.in/grXaAjm8 #CProgramming #SoftwareDevelopment #LowLevel #TechBlogging #CodingLife

Today I went down a rabbit hole… and it started with a simple C question. Why does this print 10? unsigned int x = 0; int y; y = -1 > x ? 10 : 20; printf("%d", y); At first glance, you’d think: -1 > 0 → false → so 20, right? Wrong. It prints 10. And that tiny confusion led me into one of the most fascinating deep dives I’ve had in a while. Here’s what I explored today 👇 🔹 Signed vs Unsigned conversions When signed and unsigned integers are compared, C silently converts the signed value to unsigned (if they have the same rank). So -1 becomes 4294967295 (on a 32-bit system). Now the comparison becomes: 4294967295 > 0 → true. Mind blown. 🔹 2’s Complement & Bit Interpretation Same bit pattern: 11111111 11111111 11111111 11111111 As signed → -1 As unsigned → 4294967295 Memory stores bits. Type decides interpretation. 🔹 Compile Time vs Runtime I used to casually say “the variable exists.” But today I asked myself — when exactly does it exist? While typing in VS Code? ❌ During compilation? ❌ Only after the OS loads the executable into memory and the process starts? ✅ That changed how I think about programs entirely. 🔹 What actually happens when we run gcc main.c? C file → Preprocessor → Compiler → Assembly → Assembler → Machine Code → Linker → Executable → OS loads → CPU executes. VS Code is just a text editor. The real magic happens in the toolchain and inside the CPU. What I realized today: Programming is not just about writing code. It’s about understanding what really happens underneath. The deeper you go, the more elegant the system looks. And honestly… this is the part of computer science that excites me the most. Curiosity → Clarity → Depth. Still learning. Still exploring. 🚀 #computerscience #cprogram

Rust's type system prevents an entire class of bugs that plague other languages: the dreaded "billion-dollar mistake" of null pointer exceptions. Instead of nullable types that can crash at runtime, Rust uses `Option<T>`: • `Some(value)` represents a present value • `None` represents absence - but safely! • Pattern matching forces you to handle both cases • No surprise null pointer crashes in production • Compiler ensures exhaustive handling The magic happens at compile time. You literally cannot access a potentially absent value without explicitly checking for it first. This design makes impossible states unrepresentable in your type system. Languages with nulls make absence invisible until runtime. Rust makes presence and absence explicit in the type signature, turning runtime crashes into compile-time guarantees. This is systems programming without the fear of production crashes from forgotten null checks. Explore more Rust content at rustlab.dev #RustLang #TypeSafety #SystemsProgramming #SoftwareEngineering