Is Jeff Bezanson's 2014 "Introduction to Julia Internals" relevant in 2021 onward?

I’m kind of fan of Jeff Bezanson’s talks and recently I watched his talk from first JuliaCon 2014 titled Introduction to Julia Internals. I found there many information that were totally new to me about internal working of the Julia, but since talk is from 2014 many things may or may not change. My knowledge about such things is approximately 0, so I don’t know what part of Julia, or any programming language, is stable and what is in flux.

If most of the talk is still relevant, it is very valuable source of information, since I didn’t find any other talk on YT diving so much into internal working of Julia. In such situation I think it would be good idea for me to watch it again and at timestamps to it. This is small thing, but I can’t do much more.

If is too outdated, is there any other similar source with such information to watch/read? This is probably silly question, but to this moment I didn’t find anything like that. I don’t count Julia documentation, since it now over 1000 pages long and I never read beyond first part of it.

I apologize for all language mistakes. My English is bad and not good.

Still mostly accurate, I suspect. Have you checked out the dev docs?


Thank you for the answer. In such situation I will watch it and try to make timestamps of it.

No. As I said, I never dived reasonably dip into documentation.

I created timestamps for this talk and put them in appropriate GitHub issue. Feel free to correct and change everything in them.

00:00 Origin story
00:28 Aim of the talk
00:57 Three component of programming language: data model, code model, glue
03:02 Tag-bits arrangement
04:34 Type primitives
05:45 Object graph of types
06:48 Code object primitives
07:41 Code intrinsics
08:15 Translation stages
10:09 Test subject
10:17 Julia is just lisp
12:04 “You can call various functions, that are of curse not documented.”
14:03 Parsed test subject code
16:00 Expanding macros
17:17 Syntax de-sugaring
18:52 Are |#s number| symbols related to LLVM code?
19:23 Statementize control flow
20:18 Flattening code using goto form
21:47 Flattened code in @code_lovered form
22:13 Would it be any worth in reading code in goto form?
22:53 Why we have in code statements like “6: goto 7”?
23:45 Running the code
24:51 Method cache (file gf.c)
27:23 Overview of type inference
28:30 Compile-time method lookup and secret internal function
30:07 Type inference (file inference.jl)
30:50 Inlining, high-level optimisation
31:32 LLVM IR generation
31:42 Code generation key concepts
32:52 emit_expr and emit_function
35:03 Type translation between Julia and LLVM
35:35 Q&A: When is the most time spent at runtime?
36:30 Q&A: Do you plan to extend syntax to add new feature?
37:24 Q&A: Do LLVM and garbage collector allow static analysis?
38:52 Q&A: Stack and heap allocation
39:16 Q&A: Can I press button and get graph of whole architecture?
39:43 Q&A: Better mechanism for simple unions
40:17 Q&A: Types lookup and exponential complexity
40:50 Q&A: How many types Julia look up before giving up?
42:01 Q&A: How “widening” of types works?
43:27 Q&A: What are the heuristic that decided that something is inline or not?