awesome-internals
A curated list of awesome resources and learning materials in the field of X internals
https://github.com/ghaiklor/awesome-internals
Last synced: 5 days ago
JSON representation
-
Interpreters/Compilers
- Juozas Kaziukėnas - Building An Interpreter In RPython - PyCon 2016 - a speech on how was built PHP interpreter with RPython.
- A closer look at Crankshaft, V8's optimizing compiler, by Andy Wingo - continuing in my series of articles on V8, Google's JavaScript engine, in this article I'd like to take a closer look at V8's optimizing compiler, with a focus on the Hydrogen intermediate language.
- A Simple Graph-Based Intermediate Representation, by Cliff Click, Michael Paleczny - a paper where they present a graph-based intermediate representation (IR) with simple semantics and a low-memory-cost C++ implementation.
- A tour of V8: Crankshaft, the optimizing compiler, by Jay Conrod - an intro into Crankshaft, optimizing compiler in V8, before Turbofan.
- An Introduction to Speculative Optimization in V8, by Benedikt Meurer - how TurboFan, V8’s optimizing compiler, works and how V8 turns your JavaScript into highly-optimized machine code.
- Build Your Own Lisp, by Daniel Holden - a book about how to implement your own Lisp language with C compiler.
- Combining Analyses, Combining Optimizations, by Cliff Click - this paper presents a framework for describing optimizations. It shows how to combine two such frameworks and how to reason about the properties of the resulting framework.
- Compiler basics: lisp to assembly, by Phil Eaton - in this post we'll write a simple compiler in Javascript (on Node) without any third-party libraries. Our goal is to take an input program like (+ 1 (+ 2 3)) and produce an output assembly program that does these operations to produce 6 as the exit code.
- Efficient and General On-Stack Replacement for Aggressive Program Specialization, by Sunil Soman, Chandra Krintz - in this paper, we present a novel, general-purpose OSR mechanism that is more amenable to optimization than prior approaches. In particular, we decouple the OSR implementation from the optimization process and update the program state information incrementally during optimization.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- Let's Build a Compiler, by Jack Crenshaw - this fifteen-part series, written from 1988 to 1995, is a non-technical introduction to compiler construction.
- Polymorphic Inline Caching on JavaScript for fun and profit, by Chris Leary - what follows is a gentle-albeit-quirky introduction to what polymorphic inline caches (PICs) are and why they're useful to JavaScript Just-In-Time compilers like JaegerMonkey.
- Speculation in JavaScriptCore, by Filip Pizlo - this post is all about speculative compilation, or just speculation for short, in the context of the JavaScriptCore virtual machine.
- Understanding Compiler Optimization - Chandler Carruth - Opening Keynote Meeting C++ 2015 - talk from Chandler Carruth about compilers optimizations, implemented in LLVM.
- V8: A tale of two compilers, by Andy Wingo - advanced intro into two compilers in V8: FullCodegen and Crankshaft.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- Let’s Build a Simple Interpreter, by Ruslan Spivak - a series of articles about implementing Pascal interpreter in Python.
- Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches, by Urs Hölzle, Craig Chambers, David Ungar - a paper about polymorphic inline caches which provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
- How JIT Compilers are Implemented and Fast: Pypy, LuaJIT, Graal and More, by Carol Chen - This post goes into details of 5+ JITs and various optimization strategies and discuss how they work with different JITs.
-
Operating Systems
- How OSX executes applications, by Mohit Muthanna Cheppudira - a deep intro into how OS X executes applications, Mach-O format, etc...
- How debuggers work, by Eli Bendersky - a series of articles on how debuggers work.
- How OSX executes applications, by Mohit Muthanna Cheppudira - a deep intro into how OS X executes applications, Mach-O format, etc...
- Operating System Development Series - a series of posts on how to implement your own operating system from scratch.
- Parsing Mach-O files, by Alex Denisov - this article describes how to parse Mach-O file and explains its format.
- Writing a Minimal Mach-O Executable File, by Nicolas Seriot - a story about how author writes a minimal Mach-O executable file which fits into 164 bytes and prints Hello, World.
- Writing a Simple Operating System, by Nick Blundell - self-contained and coherent document, that will give you a hands-on experience of low-level programming, how operating systems are written, and the kind of problems they must solve.
- How debugger works, by Alexander Sandler - In this article, I’d like to tell you how real debugger works. What happens under the hood and why it happens. We’ll even write our own small debugger and see it in action.
-
Courses
-
Hardware
- Demystifying the Secure Enclave Processor, by Tarjei Mandt, Mathew Solnik, David Wang - SEP is designed as a security circuit configured to perform secure services for the rest of the SOC, with no direct access from the main processor. The paper dives into its implementation and how it communicates with other components.
-
Parsers
- Learning Parser Combinators With Rust, by Bodil Stokke - this article teaches the fundamentals of parser combinators to people who are already Rust programmers. It assumes no other knowledge, and will explain everything that isn't directly related to Rust, as well as a few of the more unexpected aspects of using Rust for this purpose. It will not teach you Rust if you don't already know it, and, if so, it probably also won't teach you parser combinators very well.
-
Network
- A computer networking zine, by Julia Evans - zine about OSI layer with great examples and simplified for better understanding. What is going on under the hood, when you are requesting an image of cat, etc...
- How can an Internet work and how does the Internet work, by Stanislav Shalunov - the purpose of this book is to give an understanding of how the Internet works. We won't discuss formats of packets and such exact technical details.
- Monitoring and Tuning the Linux Networking Stack: Receiving Data, by packagecloud - this blog post explains how computers running the Linux kernel receive packets, as well as how to monitor and tune each component of the networking stack as packets flow from the network toward userland programs.
- A container networking overview, by Julia Evans - there are a lot of different ways you can network containers together, and the documentation on the internet about how it works is often pretty bad. I got really confused about all of this, so I’m going to try to explain what it all is in laymen’s terms.
-
Databases
- How does a relational database work, by Christophe Kalenzaga - a really deep explanation of how relational databases work.
- Implementing Sorting in Database Systems, by Goetz Graefe - it covers in-memory sorting, disk-based external sorting, and considerations that apply specifically to sorting in database systems.
-
Bundlers
- Let’s learn how module bundlers work and then write one ourselves, by Adam Kelly - Brief tutorial explaining how module bundlers work in Javascript by building a toy bundler.
- Un-bundling the JavaScript module bundler, by Luciano Mammino - This video explains how the module bundler Webpack works.
- Understanding webpack from the inside out, by Sean Larkin & Tobias Koppers - Video explaining the internals of Webpack: entry point, output, loaders, building a dependency graph, and utilizing plugins.
- How does Bundler work, anyway, by André Arko - Blog post explaining how the Ruby package/dependency manager handles dependencies.
-
Package Managers
- Let's Dev: A Package Manager, by Maël Nison - A tutorial explaining how package management works by building a toy package manager.
- So you want to write a package manager, by Sam Boyer - A blog post explaining the core components of a package management system: project code, manifest file, lock file, and dependency code.
Categories
Sub Categories