Andrew’s Substack

Andrew’s Substack explores the intricate relationship between formal (programming, compilers, data structures) and natural language through technical tutorials and philosophical musings. It covers compiler bootstrapping, programming language concepts, operating system functionalities, and reflections on humanity and life, blending technical depth with broader existential questions.

Compiler Design Programming Concepts Operating Systems Data Structures Philosophy of Technology Software Optimization Assembly Language Functional Programming

The hottest Substack posts of Andrew’s Substack

And their main takeaways

Strace is your friend

19 implied HN points • 18 Jan 24
  1. Strace is a command that logs system calls for a program.
  2. Strace can help identify issues like malformed system calls.
  3. Consider using strace for logging and gaining insight into program behavior.

What is a stack frame?

0 implied HN points • 10 Jan 24
  1. A stack frame starts at the base pointer, usually stored in %rbp.
  2. In a C-style calling convention, each function creates its own frame on the stack.
  3. Before exiting a function, the previous base pointer should be restored.

How to Bootstrap a Compiler for a Functional Programming Language

0 implied HN points • 31 Jan 24
  1. S-Expressions are used to represent various data structures in a functional programming compiler.
  2. The Type Signature in functional languages defines S-Expressions as Nil, Atom, and Cons.
  3. Common functions for manipulating S-Expressions include head, tail, and eq.

Contemplating "Life"

0 implied HN points • 10 Feb 24
  1. Life is full of imperfections and weaknesses; it's part of being human.
  2. Living a life for others gives meaning and purpose.
  3. Sometimes, being shot at without harm can be a form of exhilaration.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

Do We Really Need 10x Developers?

0 implied HN points • 30 Jan 24
  1. The concept of 10x developers may not be the most strategic focus for development teams.
  2. Measuring individual productivity in coding is complex and factors beyond talent contribute.
  3. Improving process to give average developers more coding time can be more reliable and sustainable than chasing elite talent.

LM v1.0.0 Release

0 implied HN points • 29 Jan 24
  1. LM v1.0.0 is a new assembler
  2. LM introduces code equivalence and metric-driven instruction selection
  3. Compiler benchmarks show quick compilation time and room for optimization

Writing to a Posix File

0 implied HN points • 23 Jan 24
  1. When writing to a file on a Linux/Unix/Posix system, use O_TRUNC to truncate the file when opening.
  2. Using O_WRONLY | O_CREAT can lead to the file being filled with data from previous files with the same name.
  3. Not using O_TRUNC can introduce bugs that are hard to analyze, reproduce, and fix in a build process.

Nuances of Fragment Assembly: Labels

0 implied HN points • 23 Jan 24
  1. Fragment Assembly involves putting data pieces together, but some file formats can be challenging.
  2. Labels in Assembly represent positions in the file and do not take up space; space is taken by references to labels.
  3. Generating labels algorithmically in two passes helps fix label references and calculate positions relative to the file's start.

What is a fragment assembler?

0 implied HN points • 21 Jan 24
  1. A fragment assembler puts smaller data pieces together to form a complete file.
  2. Typed fragment assemblers help ensure data output accuracy and improve code readability.
  3. Advancements in type theory could lead to more efficient and powerful assemblers.

The Freedom of Machine Code

0 implied HN points • 12 Jan 24
  1. Rust focuses on zero cost abstractions with safety and correctness as top priorities.
  2. In contrast, C offers well-defined behavior, putting responsibility on the programmer for usefulness and predictability.
  3. Working directly with machine code can be necessary for understanding and debugging, especially when dealing with compiler transformations.

How is a Rope different from a String?

0 implied HN points • 17 Jan 24
  1. All Strings are Rope, showcasing the benefits of Rope data structure.
  2. Rope is like a Braided String, offering an optimized way of concatenating data.
  3. Rope can be easily converted to a String if needed with minimal downsides.

Contemplating "Humanity"

0 implied HN points • 07 Feb 24
  1. Different thinkers have contrasting views on humanity.
  2. Human beings are essential for their own improvement.
  3. Natural groups play a vital role in human emancipation.

How to Bootstrap a Compiler for a Functional Language

0 implied HN points • 03 Feb 24
  1. Programs have a text section for code and a data section for data.
  2. Processing command line arguments involves converting them into an S-Expression.
  3. Memory allocation for atoms and cons cells involves tracking with a counter.

Functional Language Optimization

0 implied HN points • 28 Jan 24
  1. Imperative and functional languages both have optimization options.
  2. Unused value optimization can simplify code and remove unnecessary operations.
  3. Optimizing functional paradigms can be done using simple heuristics without complex control-flow graphs.

What is an S-Expression?

0 implied HN points • 25 Jan 24
  1. S-Expressions can be represented by a Nil, Atom, or Pair.
  2. S-Expressions are powerful in representing the Abstract Syntax Tree of various languages.
  3. Implementing S-Expressions can be straightforward with just two pointers.

Problems when trying to Type Check Assembly Code

0 implied HN points • 04 Jan 24
  1. C is a popular language with good reasons
  2. Introducing generics in C can lead to duplicate work
  3. C offers good ideas like nominal types and parameterized types for improvement

How to Bootstrap a Compiler for a Functional Programming Language

0 implied HN points • 05 Feb 24
  1. First-order functions do not need closures and have a specific format in GNU Assembly.
  2. When passing multiple arguments to a function, they must be structured in S-Expressions and then destructured into locals before use.
  3. Higher-order functions, like closures, require a more complex calling convention using far calls.

Building a Functional Expression Language within C's Type System

0 implied HN points • 30 Oct 24
🕹 Technology Programming Software Systems Development Engineering
  1. LM is a functional expression language that can generate code for different targets, including cross-compilation.
  2. To integrate LM with C, we need to convert LM types into C types, handling memory alignment and other details carefully.
  3. C's expression capabilities allow us to construct new data types and perform complex operations using simple expression syntax.

Understanding How C Strings Are Stored in the Data Section of a C Program

0 implied HN points • 24 Oct 24
🕹 Technology Programming Software Systems Development Coding
  1. Strings in C are arrays of characters that end with a null character. When you define a string, it gets stored in a specific part of the computer's memory.
  2. String literals are placed in a read-only section of memory, meaning you can't change them. Trying to change a string literal can cause your program to crash.
  3. Global and static strings can be changed because they're stored in a writable section of memory. This allows them to keep their values throughout the program's run.

The LM Type System

0 implied HN points • 22 Oct 24
🕹 Technology Programming Systems Types Logic Mathematics
  1. Lambda Calculus is about functions and variables, and it doesn't use fixed types, making it more flexible.
  2. The LM Type System builds on this by adding type distinctions, allowing for clearer function roles and hierarchies among types.
  3. It also includes logical properties for types, which means we can ensure that certain conditions are met for a type to be valid.

Programming in C with an Assembler…

0 implied HN points • 22 Oct 24
🕹 Technology Programming Software Computing Development System Design
  1. C is good for cross-platform development and handles important tasks like memory management well. This makes it easier for programmers to write efficient code.
  2. LM introduces modern programming features to C, like function templates and object-oriented programming styles. This can help make coding simpler and more powerful.
  3. The focus of LM is to tackle complex tasks that are hard in other languages, making it a valuable tool for systems programming. This means programmers can do more with less effort.

Object-Oriented Programming in LM

0 implied HN points • 17 Oct 24
🕹 Technology Programming Software Data Structures Abstraction Modeling
  1. LM does not have a traditional object model, class model, or inheritance model, but it can represent some object-oriented features.
  2. The 'Diamond Problem' in inheritance can be avoided in LM by using plural type notation, which clearly shows type relationships.
  3. LM supports features like object subtyping, runtime types, and aspect-oriented programming, making it versatile despite its assembly-like nature.

When Looking Back at Legacy Code, All You Really Want to Think Is: "This Is Reasonable"

0 implied HN points • 16 Oct 24
🕹 Technology Software Development Programming Technical Debt Documentation
  1. Legacy code should be clear and understandable. The goal is for developers to look back at it and think, 'This makes sense.'
  2. Good legacy code is simple, consistent, and has clear documentation. This helps new developers quickly understand it without getting lost.
  3. Investing time to write clear, well-documented code saves headaches later. It makes maintenance easier and helps new team members get up to speed faster.

Generics vs Templates in LM Programming

0 implied HN points • 15 Oct 24
🕹 Technology Programming Software Languages Development Coding
  1. Generics are about type erasure, which means when a general type is used, the specifics are lost. This can limit what you can do with that type unless you define its constraints.
  2. Templates are used for code generation, meaning they create specific versions of functions for each type used. This allows for more flexibility and can enable complex operations like comparisons.
  3. Zig and C++ use templates for parameterized types, which helps create specialized functions only when they are needed. This can make programming more efficient.

Lambda Mountain v1.17 Patch Notes

0 implied HN points • 11 Oct 24
🕹 Technology Software Programming Development Computing Engineering
  1. The v1.17 update enhances programming experiences with new features, making the software more user-friendly. It focuses on improving performance significantly, allowing for optimized code structures.
  2. This patch includes useful improvements like single instruction math operations, function inlining, and better project organization, which help streamline coding processes.
  3. Overall, the update promises a strong foundation for future enhancements and supports more efficient coding practices, which is essential for low-level programming.

Six Billion Unnecessary Function Calls

0 implied HN points • 10 Oct 24
🕹 Technology Programming Software Optimization Development Engineering
  1. Focus on adding features before trying to optimize your code, unless performance is a big issue. It's better to develop first and deal with optimization later.
  2. Low-level optimizations are useful for compilers, but many developers may not gain much from them. It's often smarter to enable existing optimizations like `O3` for better performance.
  3. High-level optimizations, like rethinking your code structure, help everyone. They improve performance and make the code easier to understand.

How to Bootstrap a Compiler for a Functional Programming Language

0 implied HN points • 09 Feb 24
  1. A Parser converts tokens into an Abstract Syntax Tree (AST) for a program.
  2. The goal of parsing is to transform a stream of tokens into a structured representation like a tree.
  3. The parsing process involves functions like 'parse-program', 'parse-many-expressions', 'parse-one-expression', and 'parse-lambda'.

Understanding Covariance and Contravariance in Type Theory

0 implied HN points • 13 Oct 24
🕹 Technology Programming Software APIs
  1. Covariance allows a subtype to be used where a supertype is expected, especially in collections like lists. This means that a list of cats can be treated like a list of animals.
  2. Contravariance is the opposite, where a supertype can be used where a subtype is expected, particularly in functions. This means a function that works with animals can also accept a function that works with cats.
  3. Understanding these concepts is important because they help make your code safer and more flexible, allowing you to design better APIs and reusable functions.