Designing Vex: A New Systems Programming Language

A while back, a post was making the rounds about Claude writing a C compiler. Writing a C compiler is a well-researched problem. What happens if you wander off the beaten track a bit? Some initial observations from developing the Splic compiler below. Some obvious, some perhaps less so. (1) Encapsulate domain knowledge in skills. Splic is based on two-level types, a somewhat niche concept, and its application to compilers is a relatively recent research. The very first commit in the repo was a two-level types skill. It took some effort to get the papers into a format easily digestible by the agent but it paid off handsomely. I even had Claude push back on a suggestion of mine that did not follow one of the typing rules. It is also useful to include links to the original sources so the agent can look up further detail when needed. (2) Create design documents. An example would be the syntax reference in splic. These get referenced a lot and it's handy to be able to explicitly feed them into context at any point. (3) Plan mode with a detailed initial prompt is your friend. I have to admit I only glance at the generated plan. Instead, I directly drill into known-to-be-tricky parts with some pointed interrogation. Manipulation of de Bruijn indices/levels is the prime example. Having domain knowledge is still very useful in this stage, to catch errors early or when the agent asks for clarification. (4) Agents do not take advantage of strong types as much as they could. When refactoring code, the agent often looks up all the use sites by reading a bunch of source files and grepping a lot. This might be a sensible approach when working with Python or JavaScript. However, in a Rust-based project, asking it to "just make the change and chase up the bloody compiler errors" is faster, more reliable, and easier on token consumption. All this applies to Claude Code using mostly the Sonnet 4.6 model. Splic repo: https://lnkd.in/eyj6m72z

You have no excuse not to try a new programming language when you can ask Claude Code or Codex to write it for you. Will it be perfect from the get-go? Absolutely not! Will you make a lot of mistakes? You sure will! But, that’s how you will learn about the limitations of your knowledge, and where the AI fails to help you.

Most of us know that adding strings in a loop is a performance killer. Still, even a single line of concatenation can create a "terrifying abyss" of temporary objects and unnecessary memory allocations. I just published a deep dive on Medium about String Expressions—a technique that gives you JavaScript-level syntax with performance that beats manual reserve() and append() optimization. In this post: ✅ Why std::format isn't always the answer. ✅ The hidden cost of std::to_string. ✅ How the simstr library uses lazy evaluation to achieve 20% faster results than manual C++ code. #cpp #programming #algorithms

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

Today I’m sharing something I’ve been quietly building for a while: Chuks , a new programming language designed for the next generation of high-performance systems. Modern software is becoming increasingly complex. We build systems that handle millions of concurrent tasks, real-time data streams, distributed services, and AI workloads. Yet most languages still force developers to fight with complexity instead of helping them manage it. Chuks is an experiment in rethinking that. The goal is simple: make it easier to build high-performance, concurrent, and scalable systems without sacrificing clarity or developer productivity. Some of the areas Chuks focuses on: • Massive concurrency and async execution • Efficient task scheduling • High-performance compiled binaries • A runtime model designed for modern distributed systems Chuks is still early, but the vision is to explore what a programming language could look like if it were built from the ground up for the kind of systems we build today. Over the coming weeks, I’ll share more about the architecture, design decisions, and the problems Chuks is trying to solve. If you enjoy programming languages, compilers, runtimes, or systems engineering, I’d love to hear your thoughts. The journey is just beginning. Visit https:chuks.org for more

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

LLMs still confuse me a lot for software development. How possibly you can specify something with less information than you’d do with code? It is possible that we haven’t figured out the most concise programming language yet, but it’s definitely not natural language.

Day 59 — Understanding Threads in Modern C++ Today, I explored multithreading in C++ using "std::thread." A thread is an independent path of execution within a program, allowing tasks to run concurrently rather than sequentially. Here’s a basic example: #include <iostream> #include <thread> void task() { std::cout << "Hello from thread!\n"; } int main() { std::thread t(task); t.join(); // wait for the thread to finish } Key concepts I learned include: • "std::thread" creates a new execution path • "join()" waits for a thread to finish • "detach()" allows it to run independently • Shared data between threads must be protected using "std::mutex" • Modern C++ threading is portable with "<thread>" and "<chrono>" One important lesson: not all compilers support threading equally. Some older MinGW versions don’t fully support "std::thread," highlighting the importance of understanding your toolchain alongside the language. Threads offer significant opportunities for performance, concurrency, and real-world system programming. Step by step, I am getting closer to mastering modern C++.