Series: I Tell Huiqi About

This is part 2 of 2 of a conversation I had with Huiqi Zhou where I tell her about LLVM and just can't stop talking. In this episode I show some LLVM IR code examples and explain SSA - Static Single Assignment. LLVM is an open source compiler infrastructure / framework. It contains a state of the art C compiler called clang, and if you want to make your own compiler, it can provide you with building blocks that can make your work easier.

Watch “What is LLVM? I Tell Huiqi About It. Part 2”

I've been knee deep in LLVM and in this video I talk to Huiqi about it. LLVM is a compiler infrastructure / framework. It contains a core library which you can use to build your own compiler.

Watch “What is LLVM? I Tell Huiqi About It - Part 1”

In this video with guest Huiqi Zhou I explain how strings actually work. We go over string encodings, unicode, UTF-8, UTF-16, and more using code examples in Node.js.

Watch “How Strings Actually Work - with guest Huiqi Zhou”

I demo the deep-zoom debugger to my colleague Huiqi Zhou.

Watch “Deep-Zoom Debugger Demo with Huiqi Zhou”

Huiqi and I use the analogy of a book to explain about how database work. We explore some very interesting data structures and algorithms that are used in the database.

Watch “How Databases Work”

In this video, Huiqi and I talk about the time traveling debugging I've been working on. We plan to explain the architecture and inner workings of the debugger as well as covering some important computer science concepts along the way over a series of episodes.

Watch “How Time Traveling Works”

We are with Huiqi again and this video is part 1 of a series where we walk about memory management. In this part, we will talk about how manual memory management is done in the C programming language. In upcoming episodes we'll talk about garbage collection (GC) as well as automatic reference counting (ARC).

Watch “Memory Management with malloc and free”

Toby and Huiqi have a conversation about games and education.

Watch “Games and Education”

Huiqi and Toby talk about Automatic Reference Counting - a system of automatic memory management used by some popular programming languages including Python, Object-C, Swift, Rust, and more.

Watch “Automatic Reference Counting”

Toby and Huiqi talk about the full garbage collection mechanism that is used in the most popular programming languages like JavaScript, Java, C# and more. We introduce the mark and sweep algorithm. We also compare it to ARC (Automatic Reference Counting) languages like Python, Swift, and Objective-C.

Watch “Garbage Collection with Mark and Sweep”

In this video I want to allow Huiqi and you the viewers to experience what it's like to code with a time traveling debugger. We do a medium difficulty challenge from leetcode.com called Add Two Numbers: https://leetcode.com/problems/add-two-numbers/. At the end we also go over how to get setup if you want to take the debugger for a spin yourself. You can find that info at https://github.com/airportyh/play-lang.

Watch “What it's Like to Code with a Time Traveling Debugger”

I tell Huiqi about an tool I made to automate the tedious process of a debugging technique called test case simplification (https://www.youtube.com/watch?v=zkT1DILY7e4).

Watch “Automatic Test Case Simplification Tool”

In this video I tell Huiqi about rr: a report/replay debugger for C and C++. We talk about how record/replay debuggers work using Redux as a starting point.

Watch “rr and Time-Traveling Debuggers”

In this video I tell Huiqi about David Beazley's "Write a Compiler" course and X86 registers.

Watch “dabeaz's Compilers Course And X86 Registers”

I tell Huiqi about a performance war story that took place last week.

Watch “Let's Talk About Performance”

I talk briefly with Huiqi about learning C and C++ vs more modern languages like Go and Rust.

Watch “Learning C/C++ vs Go or Rust”

We talk about performance again! We follow up on the previous week's plan to speed up the "recreate" program. Short version: it worked as predicted! Long version: watch the video. The Stackoverflow answer written by Mike Dunlavey that was cited can be found here: https://stackoverflow.com/a/1796715/5304

Watch “Let's Talk about Performance! (2)”

I rewrote some Python code in C last couple of weeks to improve the performance of the "recreate" program. Here I show a brief side-by-side comparison of the code before and after with Huiqi.

Watch “Python vs C: Side by Side (Plus Macros!)”

In this video I excitedly tell Huiqi about reverse engineering: my latest obsession.

Watch “Reverse Engineering with GDB”

I share with Huiqi (and you!) inspirational visualization concepts I learned from the book: Beautify Visualization. The first is a redesign of the NYC subway map called KickMap(http://kickmap.com/), created by Eddie Jabbour. The second is an animated visualization of the flight paths in North America by Aaron Koblin and Valdean Klump for which you can find the video here: https://www.youtube.com/watch?v=ystkKXzt9Wk.

Watch “Visual Concepts: Subway Maps and Flight Paths”

This is the second episode where I share with Huiqi (and you!) inspiring visualization concepts from the book: Beautiful Visualization. First we talk about Valdis Krebs' social graphs. Then we talk about Martin Wattenberg and Fernanda Viegas' visualization of the edit history of Wikipedia articles: http://hint.fm/projects/historyflow/.

Watch “Visual Concepts: Social Graphs and Wikipedia Edit Histories”

I am making a terminal-based UI framework for the time-traveling debugger project. Here I share what I did so far with Huiqi.

Watch “Making a Terminal-Based UI Framework”

Huiqi and I have chat about Joel Spolsky's Law of Leaky Abstractions: https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/. We touch on various topics including TCP/IP, SQL, ORMs, frameworks, and more.

Watch “Law of Leaky Abstractions”

In this chat Huiqi and I give some concrete examples of leaky abstractions. In particular, we give examples in Kubernetes/Docker, Angular, and React in which the abstraction failed to hide the details of the implementation.

Watch “Real World Leaky Abstractions 1: Kubernetes, ng, and React”

In this video I share with Huiqi a war story where I try to share TypeScript definitions among 3 projects: a nest.js project, a React-create-app project, and a React Native/Expo project. It is a classic case of a leaky abstraction: where something which seems like it should be straightforward ends up sendings me through a long series of rabbit holes.

Watch “Real World Leaky Abstractions 2: Sharing TypeScript”

Huiqi and I continue our journey into the realm of leaky abstractions. This time we give examples of low code/no code tools, i.e. code generators, Python 2's range function, and then talk about the prospect of making choices when one "has no time".

Watch “Real World Leaky Abstractions 3: Python and Having No Time”

Huiqi asks me a pressing question: what is the solution to the problem of leaky abstractions? Do I have an answer? Watch and find out.

Watch “Can Leaky Abstractions be Solved?”

Even more leaky abstractions talk! This time Huiqi and I give examples of leaky abstractions that happen in real life, as in outside of coding. Enjoy!

Watch “Leaky Abstractions IRL”

Huiqi and I talk about the notion of ejecting from a framework using React as an example and I express my problems with the concept.

Watch “Thoughts on Ejecting from a Framework”

I learned how to print a booklet on Mac OSX and happily share it here.

Watch “How to Print a Booklet on OSX”

Huiqi and I analyze the pros and cons of global/centralized control vs local/distributed control in software projects. The discussion was partly a reaction to an argument I had with my coworker. It's a fun discussion for us and it ended with a poignant moment.

Watch “Global vs Local”

This is the first status update on the time-travel debugger in a while, and I do it in Huiqi's presence. I made a windowing system on top of a UI framework I call oui. I implemented a tree widget which is now able to display composite data structures like dictionaries and object with the expand and collapse feature.

Watch “Time Machine Status Update 3”

I show Huiqi an interesting performance bug and the interesting way I visualized the execution of the code to understand the problem.

Watch “Seeing Code As Fractals”

Another status update for the time-traveling debugger.

Watch “Time Machine Status Update 4”

Huiqi and I talk about eureka moments as they are observed in programming, at least in my observations of myself.

Watch “Eureka Moments”

The Mandelbrot Set is one of the most incredible things I've ever witnessed in life. This is part 1 of a 2 part series where I share it with Huiqi and you. I give a step by step tutorial for how to create a Mandelbrot Set visualization yourself, using nothing by HTML and JavaScript. Enjoy! If you'd like, the source code produced in the episode can be found at https://github.com/airportyh/thumbprint-of-god.

Watch “How to Code the Mandelbrot Set”

This past week I've gone on an adventure learning OpenGL, WebGL, GLSL and more all in an effort to get a fast Mandelbrot Set render. It's been a ton of fun and I share my experience with Huiqi and you. Here is my repo learn-opengl where I've posted a curated list of learning resources for OpenGL: https://github.com/airportyh/learn-opengl.

Watch “GPUs, Shaders and OpenGL”

This is a conversation between Huiqi and I about the notion I have heard recently from multiple very intelligent people that software reuse is bad, which flies in the face of most current opinion. Here are my sources: https://www.youtube.com/watch?v=7YpFGkG-u1w https://www.youtube.com/watch?v=Ge3aKEmZcqY https://www.forth.com/resources/forth-programming-language/ https://www.informit.com/articles/article.aspx?p=1193856

Watch “Is Code Reuse Bad?”