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.
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.
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.
I demo the deep-zoom debugger to my colleague 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.
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.
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).
Toby and Huiqi have a conversation about 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.
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.
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.
In this video I tell Huiqi about David Beazley's "Write a Compiler" course and X86 registers.
I tell Huiqi about a performance war story that took place last week.
I talk briefly with Huiqi about learning C and C++ vs more modern languages like Go and 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
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.
In this video I excitedly tell Huiqi about reverse engineering: my latest obsession.
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.
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/.
I am making a terminal-based UI framework for the time-traveling debugger project. Here I share what I did so far with Huiqi.
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.
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.
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.
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".
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.
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!
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.
I learned how to print a booklet on Mac OSX and happily share it here.
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.
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.
I show Huiqi an interesting performance bug and the interesting way I visualized the execution of the code to understand the problem.
Another status update for the time-traveling debugger.
Huiqi and I talk about eureka moments as they are observed in programming, at least in my observations of myself.
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.
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