Bookmarks
Haskell is not category theory
What, why, who?
Topological constraints on self-organization in locally interacting systems | Philosophical Transactions of the Royal Society A | The Royal Society
Francesco Sacco, Dalton Sakthivadivel, Michael Levin; Topological constraints on self-organization in locally interacting systems. Philos Trans A Math Phys Eng Sci 14 May 2026; 384 (2320): 20250011.
A New Consciousness of Mathematics
In an age of proof abundance, what becomes scarce?
Beginner's Guide to Linkers
This article is intended to help C & C++ programmers understand the essentials of what the linker does.
A quickie: Axiom J
These definitions give rise to subtly different (but equivalent — see section §1. 12.
HoTTEST
Synthetic Stone duality is an extension of homotopy type theory with four axioms. These axioms are strong enough to decide Bishop's omniscience principles.
What makes dependent type theory more suitable than set theory for proof assistants?
In his talk, The Future of Mathematics, Dr. Kevin Buzzard states that Lean is the only existing proof assistant suitable for formalizing all of math. In the Q&A part of the talk (at 1:00:00) he
Abstracts
Thorsten Altenkirch: ‘A constructive justification of Homotopy Type Theory’ My main thesis is that Homotopy Type Theory is a foundation of mathematics that is constructive in two ways: …
nLab mathematics presented in homotopy type theory
Homotopy type theory is a formal language in which it is possible to carry out synthetic mathematics using proof assistants, such as Coq and Agda.
Tag: Homotopy Type Theory
Posts about Homotopy Type Theory written by Christopher Brinkley
Mathematics, AI, and Formalization: The State of Play
LLMs have turned a corner — from solving textbook problems to scoring top marks at the world's hardest math contests and cracking unsolved conjectures, all with minimal human oversight. How did we get here, and what does the current landscape of AI-powered formal mathematics look like?
The fall of the theorem economy
How AI could destroy mathematics and barely touch it
Running a Minecraft Server and more on a 1960s UNIVAC Computer
18 bit registers, 90kb of memory, ones’ complement, powered by RISC-V.
David Jaz Myers: Paradigms of composition
MIT Category Theory Seminar
2020/10/01
©Spifong
Speaker: David Jaz Myers
Title: Paradigms of composition
Abstract:
Scientists and engineers manage the blist...
Type Theory and Propositions
One of the things that philosophers will take a lot of getting used to, if HoTT is to be taken up as a new logic for philosophy, is the idea of propositions as a kind of types.
Floating point from scratch: Hard Mode
Actually building floating point from scratch!
Programming with Categories - Lecture 1
Video lectures at MIT. See http://brendanfong.com/programmingcats.html
Lecturers: Brendan Fong, Bartosz Milewski, David Spivak
Summary: In this course we expl...
15-411 Compiler Design
Compiler Design
The Proof in the Code
The inside story of Lean, a computer program that answers the age-old question: How do you know if something is true?
Lectures on Homotopy Type Theory & Univalent Foundations [index]
Students are expected not only to attend Lecture but also to study these lecture notes; it may happen that a given lecture does not cover all the material in the notes, but you are still expected to look through the material on your own; conversely, there is often no substitute for seeing a proof or construction done “live”.
Verifying Move Borrow Checker in Lean: an Experiment in AI-Assisted PL Metatheory
I formalised and proved the correctness of Move’s new borrow checker in Lean: 39,000 lines of mechanised metatheory, produced in under a month with the help of an AI coding assistant. This post tells the story of how it went and what it means for the future of PL research.
In search of falsehood
I am a computer scientist.
Teaching AI to Make Proof Automation Work
Leonardo de Moura — Creator of Lean and Z3
Steve Awodey – Homotopy Type Theory, Logic & Philosophy | #05 aboutlogic
aboutlogic #05 | We’re joined by Steve Awodey, one of the founders of Homotopy Type Theory.
In this episode, we talk about the relationship between philosophy a...
Active control system for data stream allocation
Director, Adobe Research & Professor, University of Massachusetts, Amherst - Cited by 14,340 - Artificial general intelligence - machine learning
Exploring Flow-Lenia Universes with a Curiosity-driven AI Scientist: Discovering Diverse Ecosystem Dynamics
Automated discovery of diverse ecosystem dynamics in Flow-Lenia using AI-driven exploration. Features interactive visualization of 2000+ discovered evolutionary patterns.
The AI Bandwidth Wall & Co-Packaged Optics
Links:
- Patreon (Support the channel directly!): https://www.patreon.com/Asianometry
- X: https://twitter.com/asianometry
- Bluesky: https://bsky.app/profile/a...
In-Place 32×32 Matrix Transpose on Tenstorrent
Tenstorrent’s AI accelerators have low-level APIs that typically operate on 32×32 tiles.
A simple constraint satisfaction problem that's seemingly hard for solvers
Imagine you have some number of workers, and some number of tasks that need to be completed. Each task needs some number of workers, and for each task, only certain workers can do it.
How (and why) to Build an Automated Theorem Prover: De-mystifying Logical Inference
Presentation by Adam Pease at SRI, Menlo Park, CA. I discuss implementation details of writing an automated theorem prover in Java for first order logic. A su...
Computational Complexity and Explanations in Physics–Scott Aaronson (University of Texas at Austin)
Title: Computational Complexity and Explanations in Physics
Speaker: Scott Aaronson (University of Texas at Austin)
Date: January 8, 2026
Abstract: The fact, o...
Program verification is not all-or-nothing
There seems to be a common belief that program verification is a task that you toil at for ages until one day you see that magic word, VERIFIED.
Broken proofs and broken provers
People expect perfection. Consider the reaction when someone who has been vaccinated against a particular disease nevertheless dies of it.
Algorithms Redux: finding unexpected properties in truly minimal systems
This is a continuation of my post on the unexpected side-quests undertaken by simple algorithms.
CUDA Graphs
A CUDA graph is a series of operations (kernel launches, memory copies, etc. ) connected by dependencies.
Lenia
Lenia is a class of continuous cellular automata systems. It was the topic of the ISAL Award for outstanding paper of 2019 and an entry in the 2018 ALife Art competition which won an honorable mention.
Formalizing 100 Theorems
There used to exist a "top 100" of mathematical theorems on the web, which is a rather arbitrary list (and most of the theorems seem rather elementary), but still is nice to look at.
Emily Riehl, A New Paradigm for Mathematical Proof? | Natural Philosophy Symposium 2025
The inaugural Natural Philosophy Symposium was held in Baltimore on May 29-31, 2025. It was sponsored by the Natural Philosophy Forum at Johns Hopkins (https://...
Lecture 22 - Kolmogorov Complexity + Halting Problem + Godel Incompleteness
Taken from: Logic for CS, Shai Ben-David, U Waterloo Fall 2015
https://www.youtube.com/channel/UCg9V0y9_RxG7hg5GjcyS2OA
Uploader: Adrian Apostol
Duration: 4654s...
The Past, Present and Future of Programming Languages - Kevlin Henney - ACCU 2025
ACCU Membership: https://tinyurl.com/ydnfkcyn
---
The Past, Present and Future of Programming Languages - Kevlin Henney - ACCU 2025
---
Programming languages ...
Bourbaki vs. Category Theory: What is Mathematics About?
What does a mathematical theory consist of? This question was at the heart of the foundational dispute between the members of Bourbaki and practitioners of cate...
RISC-V Oral History Panel
Interviewed by Dag Spicer on 2025-08-20 in Mountain View, CA
© Computer History Museum
This interview is with three principal designers and architects of the R...
Lecture 88: TinyTPU
William Zhang - TinyTPU
Uploader: GPU MODE
Duration: 3270s
Views: 3502
Malloc tutorial
This is basically an expanded explanation of what I did after reading this tutorial by Marwan Burelle and then sitting down and trying to write my own implementation, so the steps are going to be fairly similar.
Inside NVIDIA GPUs: Anatomy of high performance matmul kernels
From GPU architecture and PTX/SASS to warp-tiling and deep asynchronous tensor core pipelines.
Performance Hints
An open-source collection of core C++ library code
Formalizing the proof of PFR in Lean4 using Blueprint: a short tour
Since the release of my preprint with Tim, Ben, and Freddie proving the Polynomial Freiman-Ruzsa (PFR) conjecture over $latex {\mathbb F}_2$, I (together with Yael Dillies and Bhavik Mehta) have st…
GitHub - JOSHCLUNE/LeanHammer
Contribute to JOSHCLUNE/LeanHammer development by creating an account on GitHub.
BOLT Open Projects
Below is the list of BOLT project ideas with a brief description of each. Once a project is picked for active development, expect to start a new topic and file an RFC when suitable. Comment on this thread to add new ideas to the list. CFG Disassembler. BOLT symbolizes disassembly output and reconstructs control flow for detected functions, including that for indirect branches corresponding to jump tables. Such functionality by itself is useful for analyzing binary code. BOLT outputs the cont...
GitHub - SorryDB/sorrydb-data: SorryDB data
This repository contains various json files indexing sorries in public Lean 4 repositories. They are generated using the crawler developed in the SorryDB project.
Compiler Theory Links
I found these papers/links useful when writing the PP and GP compiler backends, so I'm saving them here. I'll try to list them front->back t...
intro-embdedded-rust/intro-attiny at main · swallez/intro-embdedded-rust · GitHub
Source code for the "Introduction to embedded Rust" talk - swallez/intro-embdedded-rust
12/07: Day 7 🎄
Refresh and Reload: Secrets of the Unified Buffer
What We Take For Granted
This is the lightning(-ish) talk I gave at TigerBeetle 1000x World Tour Belgrade,
transcribed to article form. Huge thanks to Ludwig
for hosting the event and the TigerBeetle folks
for setting it up.
The slides are available in PDF format as well.
WikiChip Fuse
WikiChip is the preeminent resource for computer architectures and semiconductor logic engineering, covering historical and contemporary electronic systems, technologies, and related topics.
The Easiest Way to Build a Type Checker
Type checkers don't have to be crazy complicated.
2D Graphics on Modern GPU
Is the traditional 2D imaging model nearing the end of its usefulness, or does it have a shiny future in the “modern graphics” world? I spent a week on a research retreat in a cottage in the woods to answer this question, as it shapes the future of UI toolkits. Performant UI must use GPU effectively, and it’s increasingly common to write UI directly in terms of GPU rendering, without a 2D graphics API as in the intermediate layer. Is that the future, or perhaps a mistake?
How I learned Vulkan and wrote a small game engine with it
The personal website of Elias Daler about programming, technology and videogames
No More Train-Inference Mismatch: Bitwise Consistent On-Policy Reinforcement Learning with vLLM and TorchTitan
We demonstrate an open-source bitwise consistent on-policy RL run with TorchTitan as the training engine and vLLM as the inference engine. Built on top of vLLM’s recent work on batch-invariant inference, we show how to run an RL fine-tune of Qwen3 1.7B with bitwise matching training and inference numerics in our open-sourced instructions:
Introduction to Theoretical Computer Science
Textbook on Theoretical Computer Science by Boaz Barak
InvisiCaps: The Fil-C Capability Model
Fil-C ensures memory safety of all operations in the C and C++ language. The hardest part of C memory safety is pointer safety.
Fil's Unbelievable Garbage Collector
Fil-C uses a parallel concurrent on-the-fly grey-stack Dijkstra accurate non-moving garbage collector called FUGC (Fil's Unbelievable Garbage Collector).
Transparent Hugepages: measuring the performance impact
Explains Transparent Hugepages in a nutshell, techniques that can be used to measure the performance impact, shows the effect on a real-world application.
From Malloc to Microseconds: Arena Allocation in OLTP Systems
In an OLTP database processing 1 million transactions per second, every microsecond matters. Each transaction allocates dozens of temporary objects: query ...
Pyrefly: Type Checking 1.8 Million Lines of Python Per Second
How do you type-check 1.8 million lines of Python per second? Neil Mitchell explains how Pyrefly (a new Python type checker) achieves this level of performance....
Book draft: “Control structures in programming languages”
I am happy to announce that a draft of my upcoming book “Control structures in programming languages: from goto to algebraic effects” is now available at https://xavierleroy.org/control-structures . The book compares several programming languages from the standpoint of control structures. OCaml is used intensively to discuss control in functional programming, including continuation-passing style, control operators, exceptions, user-defined effects and effect handlers, with many examples that I...
Visualizing all books of the world in ISBN-Space
Libraries have been trying to collect humanity’s knowledge almost since the invention of writing. In the digital age, it might actually be possible to create a comprehensive collection of all human writing meeting certain criteria That’s what shadow libraries do - collect and share as many books as
the bug that taught me more about PyTorch than years of using it
a loss plateau that looked like my mistake turned out to be a PyTorch bug. tracking it down meant peeling back every layer of abstraction, from optimizer internals to GPU kernels.
Not Just Scale
My name is Marc Brooker. I've been writing code, reading code, and living vicariously through computers for as long as I can remember.
Fast LLM Inference From Scratch
Pushing single-GPU inference throughput to the edge without libraries
They Rebuilt this Whole Game in UE5
Mecha BREAK is finally here! https://t.mechabreak.com/c/yfzzso Thank you to Amazing Season Games for Sponsoring this video
►Follow my Twitch! https://www.twitc...
Oxidize Conference: How Rust makes Oxide possible
As #rust gets more and more production usage, many of the examples people talk about are fairly high level: things like web applications. While that’s great, is...
Big Data and AI at the CERN LHC by Dr. Thea Klaeboe Aarrestad
The CERN Large Hadron Collider (LHC) generates an unprecedented O(10,000) exabytes of raw data annually from high-energy proton collisions. Managing this vast d...
Sam H. Smith – Parsing without ASTs and Optimizing with Sea of Nodes – BSC 2025
Sam H. Smith's talk at BSC 2025 about implementing AST-free compilers and optimizing with sea of nodes.
Sam's links:
- https://x.com/SamHSmith2
- https://samhs...
How far can I broadcast LoRa packets WITHOUT a radio? - LoLRa
Code/Writeup/Resources: https://github.com/cnlohr/lolra
LoLRa Merch: https://cnlohr-shop.fourthwall.com/
Patreon: https://patreon.com/cnlohr
Memes, in order of...
Speedrunning 30yrs of lithography technology
Try SendCutSend 15% off for your next project! https://sendcutsend.com/breakingtaps/
My descent into madness, chasing one micrometer.
Watch this ad-free on Ne...
Bidirectional Type Checking
Compose NYC 2019
Speaker: David Christiansen
When implementing a type checker, one must answer two questions: how to compare types for sameness, be it a subsum...
Beyond Sequential Consistency - Leveraging Atomics for Fun & Profit - Christopher Fretz C++Now 2025
https://www.cppnow.org
---
Beyond Sequential Consistency - Leveraging Atomics for Fun and Profit - Christopher Fretz - C++Now 2025
---
In 2011, C++ introduce...
Avi's Permanent Impact on Me - Scott Aaronson
A Celebration of Mathematics and Computer Science
Celebrating Avi Wigderson's 60th Birthday
October 5 - 8, 2016
More videos on http://video.ias.edu
Uploader: I...
Professor Avi Wigderson on the "P vs. NP" problem
Avi Wigderson is a professor of Mathematics at the Institute for Advanced Study in Princeton. After studying Computer Science at Technion in Haifa, he obtained ...
"A Theoretical Computer Science Lens on Consciousness" by Lenore Blum, Manuel Blum, and Avrim Blum
This is a ~ 1 hour and 10 minute talk plus ~30 minutes Q&A discussion with the computational group in our Center, titled "A Theoretical Computer Science Lens on...
The ULTIMATE Deadlock Movement Guide – Master Every Trick (Beginner to Advanced)
Coaching form: https://forms.gle/N2ue7X8YzoTRtLJM7
Where To Follow Me!
My Twitch: https://www.twitch.tv/piggyxdd
My Twitter: https://twitter.com/piggyxdd
Pig...
The Ruliology of Lambdas
Stephen Wolfram explains the rich ruliology of lambdas, made particularly significant by their connection to practical computing. Covers basic computations to undecidability to multiway graphs and evaluation strategies.
Visualizing 6D Mesh Parallelism
Plus some lore
Inside vLLM: Anatomy of a High-Throughput LLM Inference System
From paged attention, continuous batching, prefix caching, specdec, etc. to multi-GPU, multi-node dynamic serving at scale.
The Parallelism Mesh Zoo
When training large scale LLMs, there is a large assortment of parallelization strategies which you can employ to scale your training runs to work on more GPUs.
POMDPs for Dummies
Tutorial for learning about solving partially observable Markov decision processes (POMDPs).
What Alan T. did for his PhD
We’ve all been there before: by the time you start graduate school in Princeton, you’ve already invented the Turing machine, pioneered the concept of computational universality, and pro…
Lecture 3: Gödel, Turing, and Friends
On Thursday, I probably should've told you explicitly that I was compressing a whole math course into one lecture. On the one hand, that means I don't really expect you to have understood everything.
Solomonoff induction still works if the universe is uncomputable, and its usefulness doesn't require knowing Occam's razor
Note: I don't think this idea is original, but I couldn't find a good post going over the implications. …
How to Think About GPUs
We love TPUs at Google, but GPUs are great too. This chapter takes a deep dive into the world of NVIDIA GPUs – how each chip works, how they’re networked together, and what that means for LLMs, especially compared to TPUs. This section builds on Chapter 2 and Chapter 5, so you are encouraged to read them first.
PyTorch is dead. Long live JAX.
Usually, people start these ‘critiques’ with a disclaimer that they are not trying to trash the framework, and talk about how it’s a tradeoff.
Affine Dialect and OpenMP
Personal Blog
Program Synthesis: The λ in the Machine
Personal blog of Stephen Diehl - Software engineer writing about technology, programming, and the future
Dependent types in Haskell - Sort of
The glorious Glasgow Haskell Compilation system, since around version 6. 10 has had support for indexed type familes, which let us represent functional relationships between types.
Tiny-TPU: the why and how
An attempt to understand and build a TPU—by complete novices.
Designing a SIMD Algorithm from Scratch
Another explainer on a fun, esoteric topic: optimizing code with SIMD (single instruction multiple data, also sometimes called vectorization).
Jujutsu For Busy Devs
Jujutsu (jj) is a version control system with a significantly simplified mental model and command-line interface compared to Git, without sacrificing expressibility or power (in fact, you could argue Jujutsu is more powerful).
The Cricket Language
Cricket is a lazy gradually-typed functional language with objects. It's very tiny but very expressive; anyone can implement it themselves!
An Introduction to Proofs with Dependent Types
This post introduces the basic ideas behind dependent-type-based proof assistants, and expressing logic with types and values.
A Beginner's Guide to Programming Language Academia
This post briefly maps out many different subfields of programming language theory, in an effort to make it more accessible to those outside academia.
Par Part 1: Sequent Calculus
Sequent Calculus is a way of doing logic that's very explicit and mechanical. It's used as an important system and notation for type theory and logic related to programming languages.
How does Lean work and what can it prove?
the quick and dirty of Lean
Lectures on Principles of Dependent Type Theory
This is a series of lectures aimed at graduate students on the modern design of full-spectrum dependent type theories, such as the core calculi of proof assistants like Agda, Coq, and Lean.
3D Gaussian Splatting
Deep technical walkthrough of the “3D Gaussian Splatting” paper, explaining the algorithm, rendering pipeline, and codebase for real-time NeRF-style scene recon...
Keynote: Linus Torvalds, Creator of Linux & Git, in Conversation with Dirk Hohndel
Fireside keynote with Linus Torvalds covering the evolution of the Linux kernel, open-source development practices, and future directions of operating-system en...
Our video editor is actually kinda useable
Stream shows iterative development of a custom video editor, implementing multi-clip support and interactive GUI controls for clip bounds, demonstrating real-wo...
ThePrimeagen On Running Linux
Conversation detailing why ThePrimeagen runs a dedicated Linux workstation, discussing kernel-level efficiency, tooling, and developer workflow benefits compare...
Zig in Depth: Vectors and SIMD
In-depth explanation of Zig’s vector types and how they compile down to SIMD instructions, illustrating low-level data layout, intrinsic operations, and perform...
Hacking Raylib
Live-coding session in C that modifies and debugs Raylib to extend the Musializer project, covering real-time rendering techniques, event handling, and practica...
3D in TypeScript using Ray Casting
Walk-through of implementing a classic ray-casting engine in TypeScript, rendering a 3D maze in the browser while explaining projection math and performance con...
A simple socket example in Ziglang. No Talking Asmr Coding.
Silent “ASMR” coding demo that builds a minimal client/server socket program in Zig, covering socket creation, binding, listening, and message exchange.
03 CUDA Fundamental Optimization Part 1
Detailed lecture on foundational CUDA performance techniques—memory coalescing, occupancy, and kernel launch parameters—illustrated through hands-on code profil...
Who needs malloc anyways?
Live-coded session that implements a bump allocator from scratch, demonstrates eliminating dynamic malloc calls during module initialization, and refactors depe...
zig on the client, wasm on the server, what am i doing
Live-coding session that compiles a Zig simulation to WebAssembly, deploys it server-side and hooks it to a browser client, demonstrating build flags, WASM bind...
Computer Architecture Explained With MINECRAFT
Uses Minecraft’s Redstone to illustrate how real computers are built, explaining logic gates, registers, ALUs, memory and clocking at the hardware / low-level c...
Linux Signals. I Spent 2 Years to Understand This Part.
In-depth exploration of Linux signal handling internals, tracing the kernel path from interrupt to sigreturn, showing register preservation, stack manipulation,...
Yabai - Tiling Window Manager for macOS - A First Look - Effective Remote Work
Practical first-look tutorial on installing, configuring, and effectively using the Yabai tiling window manager on macOS to improve keyboard-driven window manag...
My Retro 3D Engine is Ready
Live-coding session showing the step-by-step design and implementation of a retro ray-casting 3-D engine in C, covering rendering math, engine architecture, and...
ARM Assembly: Lesson 1 (MOV, Exit Syscall)
Step-by-step lesson introducing ARM assembly programming—registers, MOV instruction, SWI syscall, compiling, and emulation—providing foundational skills for low...
The most important talk on programming by Jonathan Blow
Jonathan Blow critiques modern software practices and argues for simpler, more efficient programming models, discussing language and tooling design principles t...
Zig Roadmap 2023 - Andrew Kelley
Andrew Kelley outlines the 2023 roadmap for the Zig programming language, detailing planned language features, compiler back-end work, tooling, and data-oriente...
100+ Linux Things you Need to Know
Rapid-fire tutorial summarizing 100+ foundational Linux concepts—kernel vs GNU, essential commands, distro choices—aimed at beginners setting up and using Linux...
I Designed A CPU (And So Can You)
Project showcase guiding viewers through designing and breadboarding a custom CPU (GIBCPU), covering instruction set planning, control logic, ALU implementation...
2022 - Non-Euclidean Doom: what happens to a game when pi is not 3.14159…
Conference talk modifying Doom’s source to use intentionally incorrect π and trigonometric constants, demonstrating how breaking fundamental maths produces non-...
Elite: "The game that couldn't be written"
Deep dive into the 8-bit game Elite, showing how procedural generation, split-screen 3D, back-face culling and tight 6502 assembly fit a full universe into 22 K...
How a Clever 1960s Memory Trick Changed Computing
Historical and technical tour of virtual memory—paging, MMUs and TLBs—from the Atlas supercomputer to modern x86/ARM/RISC-V, detailing how hardware and OS coope...
The Most Complicated Algorithm I've Ever Written: SQLite B-Tree Balancing
Walk-through of the SQLite 2.x B-tree page-balancing routine, recreated in Rust; visually explains node splitting, merging and re-linking, giving implementation...
Procedural Generation using Constraint Satisfaction
Demonstrates applying constraint satisfaction algorithms to procedural content generation, detailing algorithmic concepts and code examples for maps, plants, an...
DragonflyDB Architecture Overview, Internals, and Trade-offs - hitting 6.43 million ops/sec
Technical deep dive into DragonflyDB’s architecture, concurrency model, memory layout, and trade-offs that enable >6 M ops/sec in a Redis-compatible distributed...
Advanced C: The UB and optimizations that trick good programmers.
Explores how undefined behavior in C enables aggressive compiler optimizations, illustrating subtle performance-related bugs and best practices for writing safe...
I made a Compiler in 25 Days - Here is what I learned
Step-by-step retrospective on building a full COOL compiler in C—including lexer, parser, type checker, IR, and x86 assembly backend—highlighting practical impl...
CRAFTING A CPU TO RUN PROGRAMS
Step-by-step project that assembles fundamental digital components into a functioning minimalist CPU, explaining instruction decoding, control signals and integ...
Failure & Change: Principles of Reliable Systems • Mark Hibberd • YOW! 2018
Conference talk distilling principles and practices for designing, operating and evolving large-scale, failure-tolerant software systems, with emphasis on compl...
Rendering and texturing a rotating rectangle in software
Live coding session that builds a WebAssembly software renderer from scratch, adding stb_image loading, alpha blending and rotation logic to texture-map a recta...
APL vs BQN vs Uiua
Walk-through comparing array-oriented languages APL, BQN and Uiua by re-implementing and refactoring the standard-deviation algorithm, highlighting language sem...
4 Months of Game Programming With My Own Engine
Vlog-style chronicle of building a custom OpenGL-based game engine over four months, sharing source code, rendering techniques, and learning resources, effectiv...
Proficient Parallel Programming - King Butcher - Software You Can Love VC 2023
Practical talk on parallel programming that outlines why naïve multithreading can degrade performance and details debugging techniques, cache effects, and CPU u...
ATTACK of the KILLER FEATURES - Martin Wickham - Software You Can Love Vancouver 2023
Deep dive into two interacting Zig language features—Result Location Semantics and Parameter Reference Optimization—exploring their compiler-level trade-offs, p...
Casey Muratori | Smart-Pointers, RAII, ZII? Becoming an N+2 programmer
Casey Muratori analyzes smart-pointers, RAII, Rust’s borrow checker, and zero-initialization, advocating alternative memory-handling and error-handling patterns...
Exploring Verse, Haskell, Language Design and Teaching (with Simon Peyton Jones)
Simon Peyton Jones discusses small-core language design in Haskell and the new Verse language, delving into functional-logic programming concepts and their educ...
Jonathan Blow on the Design of Jai
Jonathan Blow outlines the design philosophy, type system, and compilation goals of his Jai programming language, offering insights into modern language design ...
Zig Master: Let's Create a Trie!
Step-by-step tutorial in Zig that builds a Trie, handles manual memory allocation/freeing, and benchmarks lookup performance, demonstrating practical data-struc...
Jonathan Blow - The Gauntlet
Jonathan Blow’s talk “The Gauntlet” critiques contemporary software practices and outlines design principles and language-level features (drawn from his Jai wor...
Improving Learn OpenGL's Text Rendering Example | Adventures in Coding
Walk-through of refactoring LearnOpenGL’s font-rendering sample—profiling GPU/CPU bottlenecks, redesigning glyph batching, and achieving a 10× frame-rate improv...
Adding File Manager to My Text Editor
A live coding session adding a file-manager panel to a custom text editor, showcasing practical C programming, UI integration, and iterative development workflo...
A* Search: How Your Map Applications Find Shortest Routes
A guided derivation and proof-oriented explanation of A* search and related path-finding algorithms used in mapping applications, emphasizing optimality and heu...
Simple Code, High Performance
A case study demonstrating how refactoring large, complex codebases into simpler designs can yield order-of-magnitude speedups, with detailed profiling and opti...
Zig in Production - Jens Goldberg
A practitioner talk on adopting the Zig programming language in real-world production environments, covering build system details, tooling, deployment lessons, ...
Refterm Lecture Part 5 - Parsing with SIMD
Technical lecture showing how to accelerate text parsing by leveraging SIMD instructions, delving into low-level CPU mechanics, data alignment, and practical co...
Lightning Talk: Your Favorite Undefined Behavior in C++ - JF Bastien - CppNow 2023
Lightning talk on C++ undefined behavior, illustrating how compilers leverage UB for optimization, why certain constructs are risky, and what developers need to...
Data Oriented Programming in Java 21 by Nicolai Parlog
Conference talk introducing data-oriented programming in Java 21, outlining its four core principles and showing how records, sealed classes, and pattern matchi...
Visualizing memory layout of Rust's data types
A detailed tutorial that walks through binary loading, stack and heap operation, and the exact in-memory layout of Rust primitives, structs, enums, and smart po...
How rust forces you to respect memory
Introductory talk on Rust’s ownership, borrowing, and lifetime system, demonstrating how the language enforces safe memory access and prevents common errors suc...
Understanding Compiler Optimization - Chandler Carruth - Opening Keynote Meeting C++ 2015
Chandler Carruth explains how modern C++ compilers perform optimization passes, inlining, and code generation, helping developers write code that the optimizer ...
Making a simple Dynamic Memory Allocator (malloc)
Walk-through of implementing a minimal malloc-style dynamic memory allocator in C, covering free lists, block headers, splitting/merging, and alignment concerns...
CppCon 2016: Timur Doumler “Want fast C++? Know your hardware!"
CppCon talk illustrating how cache hierarchies, branch prediction, alignment, and SIMD influence C++ performance and providing guidelines for writing hardware-c...
Simple Artificial Neural Network entirely in assembly language
Demonstrates building and training a single-layer neural network entirely in x86-64 assembly language, covering forward pass, MSE loss, back-propagation, and lo...
Casey Muratori on his work experience
A wide-ranging interview with Casey Muratori focusing on lessons learned from decades of writing highly optimized code and cultivating a performance-aware progr...
Microservices are Technical Debt
An in-depth critique of microservices as a software-architecture pattern, weighing their impact on developer productivity, maintainability, and long-term techni...
Database Scalability
University lecture surveys database scalability techniques—sharding, replication, consistency models, and fault tolerance—framing them within distributed-system...
C++ cache locality and branch predictability
Practical C++ demonstration of how cache locality and branch prediction affect real-world runtime, showcasing code patterns and optimizations to exploit modern ...
OSI and TCP IP Models - Best Explanation
Detailed instructional walkthrough of the OSI and TCP/IP networking models, explaining each layer’s protocols and responsibilities for practitioners learning co...
Zen 5 And AI Doom w/ Casey Muratori
Extended conversation with Casey Muratori analysing AMD’s upcoming Zen 5 CPU micro-architecture and how hardware design choices (caches, branch predictors, inst...
Day 26 of Building An Operating System | Programming every day day 100
Daily livestream coding session that incrementally implements core kernel functionality—memory management, drivers, and boot code—while explaining practical OS ...
Stephen Wolfram - Where the Computational Paradigm Leads (in Physics, Tech, AI, Biology, Math, ...)
Stephen Wolfram’s keynote explores the broad “computational paradigm” as a unifying lens across physics, technology, AI, biology and mathematics—an ideas-driven...
Episode 048: Why TigerBeetle Is So Slow, With Tobi!
A live coding / debugging session with the TigerBeetle team that digs into tracing, measurement and architectural choices to diagnose the latency bottlenecks in...
Jacob Pratt: "Compiler-Driven Development: Making Rust Work for You" | RustConf 2024
RustConf 2024 talk demonstrating how developers can leverage Rust’s compiler diagnostics, type system, and tooling to iteratively write correct, idiomatic code—...
The Tech Poutine #23: AMD's Moving to 2nm
Long-form industry analysis show covering semiconductor manufacturing roadmaps, AMD’s 2 nm “Venice” chiplets, yield calculations, HBM4, CHIPS Act developments, ...
484 - All About Dat Compiler + Some Chill Browsing (TempleOS | Livestream) [2016]
Terry A. Davis live-codes and explains portions of the TempleOS compiler and associated OS internals, providing firsthand systems-programming insight into a hom...
Why GPU Programming Is Chaotic
Walk-through of why GPU programming lacks the portability and toolchain simplicity enjoyed by CPUs, covering driver fragmentation, vendor-specific shading langu...
What Is an Interactive Theorem Prover? | Kevin Buzzard
Live demonstration of the Lean interactive theorem prover, showing how formal logic rules are encoded, manipulated, and verified, and discussing its role in mat...
What P vs NP is actually about
Explains the P vs NP problem by reducing arbitrary algorithms to SAT circuits, illustrating NP-completeness, reversibility, and implications for cryptography.
Custom Floating-Point Formats
This document describes the custom floating-point formats supported by the Tenstorrent Wormhole B0 architecture. These formats deviate from IEEE 754 standards in specific ways to optimize for AI workl
Understanding B-Trees: The Data Structure Behind Modern Databases
Clear, in-depth explanation of B-trees, a fundamental data structure used in databases and file systems.
Go isn’t secure?!? feat. Low Level Learning | 053
Podcast episode delving into C, low-level programming, debugging, tooling, and security topics—valuable insights for systems programmers.
"Boundaries of Language Design" with Andrew Kelley & Ginger Bill
In-depth discussion with two language designers on compiler construction and programming-language paradigms—relevant, expert-level content.
Halting Problem & Quantum Entanglement 2020 Breakthrough result [MIP*=RE]
Clear technical explanation of the groundbreaking MIP*=RE complexity-theory result—valuable foundational content for theoretical computer scientists.
04 CUDA Fundamental Optimization Part 2
Lecture on CUDA fundamental optimizations provides specialized technical guidance for high-performance GPU computing.
Making Systems Programming Accessible by Andrew Kelley
Conference keynote by Zig creator Andrew Kelley on lowering barriers to systems programming is directly relevant to professional development in low-level softwa...
Jonathan Blow on how an operating system should work
Discussion clip where Jonathan Blow outlines principles for operating-system design offers conceptual insights relevant to systems programmers.
Writing a Compiler and Interpreter in Rust - Part 1
Step-by-step series on writing a compiler and interpreter in Rust is a valuable, in-depth educational resource on compiler construction.
Migrating from Zig to Jai
Live-coding session showing how to port code from Zig to the experimental Jai language provides practical insight into systems-level programming and language de...
Rope Datastructure
Technical presentation of the rope data structure with code overview, useful for efficient string manipulation knowledge.
What is a Lexer (No BS explanation)
Concise educational video demystifying lexers, a core component of compiler design.
HOW TRANSISTORS REMEMBER DATA
Clear explanation of how memory storage works at the transistor level, valuable for understanding computer architecture fundamentals.
Bezier curve editor from scratch in 1 hour and 46 minutes
Live-coded walkthrough of building an interactive Bézier-curve editor with HTML Canvas, offering practical graphics and web-development techniques.
Introduction | GPU Programming | Episode 0
Introductory episode of a series on CUDA/GPU programming, providing resources and setting up the technical context for massively-parallel computing.
WTF is Build.Zig? by Ed Yu
Technical presentation explaining Zig’s build system (build.zig) to C++ engineers; practical content for build and tooling specialists.
[PLDI24] Descend: A Safe GPU Systems Programming Language
PLDI 2024 research talk introducing a new safe GPU programming language; highly relevant to programming-language researchers and GPU systems developers.
Zig 0.13.0 - Overview and Updates
Provides a detailed walkthrough of the Zig 0.13 release notes, covering compiler, std-lib and build-system changes—useful for programmers using or evaluating Zi...
Zig Bytes 0x00: Getting Started
Introductory tutorial for the Zig programming language, providing practical setup instructions and code examples, directly relevant to software engineering educ...
Building A Programming Language From Its Core (with Peter Saxton)
In-depth discussion on designing a programming language around its AST, covering type systems, effects, and implementation details—valuable for language and com...
Dynamic Programming isn't too hard. You just don't know what it is.
Explains the algorithmic technique of dynamic programming and is relevant for software engineers preparing for technical interviews or improving algorithmic ski...
C++26 Preview - Jeffrey Garland - C++Now 2024
Conference talk previewing upcoming C++26 language features—directly relevant technical content for software engineers.
Enter The Arena: Simplifying Memory Management (2023)
In-depth talk on arena allocators and lifetime management, offering practical memory-management strategies for systems programmers.
CppCon 2018: Stoyan Nikolov “OOP Is Dead, Long Live Data-oriented Design”
CppCon lecture presenting data-oriented design versus OOP with concrete performance case studies—highly relevant to C++ practitioners.
Know your Java? by Venkat Subramaniam
Conference talk by a well-known expert examining lesser-known Java behaviors and pitfalls—valuable for practicing developers.
You CAN do error payloads in zig
Hands-on demonstration of error payload patterns in the Zig programming language; solid low-level programming tutorial content.
CppCon 2018: Jonathan Boccara “105 STL Algorithms in Less Than an Hour”
CppCon lecture systematically covering all 105 STL algorithms, a high-value educational resource for C++ developers.
Tony Hawk's Pro Strcpy
Explains a remote-code-execution exploit and provides source code, offering valuable security and reverse-engineering insights.
C3 with Christoffer Lerno -- His career and how he brought us the C3 language -- Conversation #6
Long-form technical interview with the creator of the C3 programming language covering language design and the speaker’s engineering career.
Linking can be fast (if you cheat): Roc's Surgical Linker - Brendan Hansknecht
Conference talk detailing a novel fast linking approach for the Roc language, directly relevant to compilers/linkers and build performance.
CppCon 2017: Carl Cook “When a Microsecond Is an Eternity: High Performance Trading Systems in C++”
CppCon conference talk delivering in-depth techniques for ultra-low-latency C++ systems, directly relevant to performance-critical software engineering.
How 1 Software Engineer Outperforms 138 - Lichess Case Study
Detailed case study of Lichess’s architecture and engineering practices (Scala, MongoDB, Snabbdom, bare-metal hosting) offering insights into high-impact solo d...
Writing a Software Renderer from scratch in C - Part 1
Hands-on tutorial showing how to implement a software renderer in C, relevant to graphics programming and low-level optimization.
A Crash Course in Category Theory - Bartosz Milewski
Bartosz Milewski provides an intensive introduction to category theory with programming examples, fitting both educational and theoretical criteria.
Category Theory, The essence of interface-based design - Erik Meijer
Conference-style talk by Erik Meijer connecting category theory to interface-based design and Java 8 lambdas; valuable for programmers interested in theoretical...
Expert Talk: Zig Programming Language & Linters • Andrew Kelley & Jeroen Engels • GOTO 2022
Interview with the Zig language creator discussing compiler-integrated linting and tooling—practical insights for language and tooling enthusiasts.
"Categories for the Working Hacker" by Philip Wadler
Philip Wadler’s lecture introduces category theory concepts for programmers, bridging mathematics and software development.
CppCon 2018: Alan Talbot “Moving Faster: Everyday efficiency in modern C++”
CppCon talk focused on everyday performance techniques in modern C++, directly useful for software engineers concerned with optimization.
Type Theory for the Working Rustacean - Dan Pittman
Technical presentation linking Rust’s type system with type theory and proof techniques, valuable for language theorists and systems programmers.
A Type System From Scratch – Robert Widmann
Technical presentation on building a type system from scratch, relevant to language and compiler enthusiasts.
Category Theory for the Working Hacker by Philip Wadler
Conference talk by Philip Wadler connecting category theory to programming; foundational material for programmers interested in type theory.
Dylan Patel - Inference Math, Simulation, and AI Megaclusters - Stanford CS 229S - Autumn 2024
Stanford CS 229S lecture on large-scale inference math and AI megaclusters—direct, advanced technical content useful to ML researchers and engineers.
Nicholas Matsakis (Co-Lead, Rust Design Team): "Rust Roadmap 2.0” | KEYNOTE | RustConf 2024
Keynote outlining the technical and organizational roadmap of the Rust language—important insight for systems programmers and language researchers.
Miguel Ojeda (Rust for Linux): KEYNOTE | RustConf 2024
_Note: This video contains hardcoded subtitles. For the most accurate English video transcription, please enable YouTube subtitles and select "English" under Yo...
Programming with Categories - Lecture 0
Video lectures at MIT. See http://brendanfong.com/programmingcats.html
Lecturers: Brendan Fong, Bartosz Milewski, David Spivak
Summary: In this course we e...
C++ Memory Model: from C++11 to C++23 - Alex Dathskovsky
https://cppnorth.ca/
---
C++ Memory Model: from C++11 to C++23
In the realm of C++ development, threading and memory management play a crucial role in crafti...
Why algebraic data types are important - Bartosz Milewski - code::dive 2018
Strong static typing detects a lot of bugs at compile time, so why would anyone prefer to program in JavaScript or Python? The main reason is that type systems ...
Mini Project: How to program a GPU? | CUDA C/C++
Matrix multiplication on a GPU using CUDA C/C++.
Code Repository: https://github.com/tgautam03/xGeMM
Video Notes and Code Explainers: https://0mean1sigma.com...
Joshua Liebow-Feeser: "Safety in an Unsafe World" | RustConf 2024
A talk by Joshua Liebow-Feeser (Software Engineer, Fuchsia Security, Google) at RustConf 2024 in Montreal, Canada & online on September 12. Hosted by the Rust F...
Joshua Liebow-Feeser: "Safety in an Unsafe World" | RustConf 2024
To view a version of this talk without hardcoded subtitles, click here: https://www.youtube.com/watch?v=qd3x5MCUrhw
_Note: This video contains hardcoded subtit...
Coding Game of Life in C from Scratch | Graphics | Ep. 1
✘ Links:
How I learned vim: https://amzn.to/3ONVG5R
How I learned C programming: https://amzn.to/41pvkhU
My keyboard: https://amzn.to/3Vudsih
Patreon: https://w...
34. "Course Recap" 2024 Fall ECE344 Section 1 (University of Toronto)
Appears to be a university operating-systems course recap; likely summarizes key OS concepts for the term, which is relevant academic material despite minimal d...
The Clean Code Debacle and Rhetoric Tricks - Casey Muratori vs Mr "Uncle Bob" Martin
Links to everything discussed in the video:
https://www.youtube.com/watch?v=tD5NrevFtbU
https://www.computerenhance.com/
https://www.computerenhance.com/p/clea...
You Don't Know Network Programming
Although recorded as a live Twitch stream, it is a hands-on coding session on low-level TCP/network programming with references to code and technical articles, ...
The Impact of Memory Allocators on Performance: A Deep Dive - Arthur Pastel | EuroRust 2024
This talk will explore the world of memory allocation and its impact on application performance. Memory allocators are an often overlooked topic but are the bac...
What did category theory ever do for us (functional programmers)?
What did category theory ever do for us (functional programmers)? - An extreme pragmatic and un-academic approach. Examples are in Scala.
Talk given at Scale b...
Coding a Bouncy Ball Simulation in C
✘ Get Source Code and Early Video Access on Patreon:
https://www.patreon.com/c/HirschDaniel
✘ Learn to Code:
https://app.codecrafters.io/join?via=danieldeer
C...
No, I Made The Hardest Game Ever
PLAY SKLIME HERE: https://store.steampowered.com/app/1380970/Sklime__A_Difficult_Climbing_Adventure/
Acerola's color palette generator: https://evannorton.gith...
CppCon 2017: Matt Godbolt “What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid”
http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017
—
In 2012, Matt ...
Why OCaml
A summary of why Jane Street uses OCaml, including a discussion of how OCaml fits into the broader space of programming languages. Given to our summer interns....
Bret Victor The Future of Programming
"The most dangerous thought you can have as a creative person is to think you know what you're doing."
Presented at Dropbox's DBX conference on July 9, 2013.
Al...
Category Theory for Programmers: Chapter 5 - Products and Coproducts
PL Virtual Meetup: https://www.meetup.com/Programming-Languages-Toronto-Meetup/
CtFP Textbook: https://github.com/hmemcpy/milewski-ctfp-pdf
Github Repo: https:/...
Building a UI Framework with Ty Overby
Conversation with an engineer about designing a functional UI framework in OCaml, covering architecture decisions and related tooling—fits technical-educational...
C++Now 2019: Ben Deane “Identifying Monoids: Exploiting Compositional Structure in Code”
http://cppnow.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: http://cppnow.org/history/2019/talks/
—
Composition i...
Modern CPUs Assign Registers To Speed Up Your Code - Computerphile
Modern CPUs manage to speed up even the simplest code, Matt Godbolt explains how there's a lot of juggling going on even in the simple use of registers.
Compu...
Odin experience report, 1 year into a work project
In this video I give an overview of things I've learned after using Odin professionally on the same project for a year.
Uploader: Rickard Andersson (gonz)
Durat...
January 2025 Q&A
Extended Q&A by a respected Rust educator covering numerous technical questions, development practices, and career advice—useful educational resource.
Introducing Clay - High Performance UI Layout in C
Clay (short for C Layout) is a high performance 2D UI layout library.
See the website at
https://nicbarker.com/clay
for more info, or check out the github repo...
RollerCoaster Tycoon was the last of its kind.
Patreon: https://www.patreon.com/ahoy
Merch: https://ahoy-shop.fourthwall.com/
00:00 Introduction
01:04 Chris Sawyer's Early Career
03:56 Transition to the PC
...
Lambda World 2019 - A categorical view of computational effects - Emily Riehl
In this Lambda World 2019 keynote, Emily Riehl discusses category theory and computational effects.
Slides are available here: http://www.math.jhu.edu/~eriehl...
François Chollet on OpenAI o-models and ARC
François Chollet discusses the outcomes of the ARC-AGI (Abstraction and Reasoning Corpus) Prize competition in 2024, where accuracy rose from 33% to 55.5% on a ...
Debuggers and programming from scratch with Ryan Fleury!
This time I'm joined by Ryan Fleury, who is working on RAD Debugger in Epic Game Tools (formerly RAD Game Tools). It's incredibly detailed, technical deep dive ...
How a Computer Works - from silicon to apps
A whistle-stop tour of how computers work, from how silicon is used to make computer chips, perform arithmetic to how programs run and computer graphics are dis...
Use Arc Instead of Vec
Rust lets you do efficient reference-counted strings and dynamic arrays using Arc basically just as easily as their owning (and deep-cloning) equivalents, Strin...
Jim Keller: Moore’s Law is Not Dead
EECS Colloquium
Wednesday, September 18, 2019
306 Soda Hall (HP Auditorium)
4-5p
Captions available upon request
Uploader: UC Berkeley EECS
Duration: 3893s
Vi...
Jon Gjengset - Towards Impeccable Rust
Rust is increasingly used in high-stakes sectors where errors can have serious consequences. In fields such as healthcare, aerospace, defense, and finance, soft...
Jonathan Blow on his programming language jai!
Long-form discussion with Jonathan Blow focused on the design and status of the Jai programming language—valuable insight into language design and game-engine t...
Tips for C Programming
A quick run through of some tips for programming in C that have helped with my productivity and enjoyment of the language.
Referenced in this video:
Anthony C...
Limits of Logic: The Gödel Legacy
Kurt Gödel showed that mathematical thinking cannot be captured in a formal axiomatic reasoning system. What does this deep result mean in practice? What are th...
Building Machine Learning Systems for a Trillion Trillion Floating Point Operations
Over the last 10 years we've seen Machine Learning consume everything, from the tech industry to the Nobel Prize, and yes, even the ML acronym. This rise in ML ...
System Jitter and Where to Find It: A Whack-a-Mole Experience
In this Tech Talk, Tudor Brindus, a software engineer at Jane Street, shares his expertise on reducing jitter—deviations from mean input processing times—in low...
2024 LLVM Developers' Meeting - Rust ❤️ LLVM
2024 LLVM Developers' Meeting
https://llvm.org/devmtg/2024-10/
------
Rust ❤️ LLVM
Speaker: Nikita Popov
------
Slides: https://llvm.org/devmtg/2024-10/slides/k...
Making a Better Particle Simulation in C++ (Part 2)
My code: https://github.com/keyframe41/ParticleSimulation
Part 1 video: https://youtu.be/XL8B5nzNEOc
Finally this video is done. Still have more particle ideas ...
Designing Distributed Systems with TLA+ • Hillel Wayne • YOW! 2019
This presentation was recorded at YOW! 2019. #GOTOcon #YOW
https://yowcon.com
Hillel Wayne - Author of Practical TLA+ @hillelwayne3236
RESOURCES
https://twit...
VULKAN: From 2D to 3D // C++ 3D Multiplayer Game From Scratch // LIVE TUTORIAL
To try everything Brilliant has to offer—free—for a full 30 days, visit https://brilliant.org/TheCherno . You’ll also get 20% off an annual premium subscription...
I made Soft Body Physics from Scratch
I made Soft body physics and a soft body tetris from scratch. This was supposed to take like 2 weeks and ended up taking like 6 weeks so pls enjoy.
Walaber Ent...
Trading at light speed: designing low latency systems in C++ - David Gross - Meeting C++ 2022
Trading at light speed: designing low latency systems in C++ - David Gross - Meeting C++ 2022
Slides: https://slides.meetingcpp.com
Survey: https://survey.meeti...
(Ep.73) DeepSeek CEO interview in English.
AI. DeepSeek. OpenAI. Tech competition.
Support me!
Donation and Support:
https://buymeacoffee.com/windspiritz
https://www.patreon.com/Awakening_Richard
Upl...
Arena Allocator, Stack Allocator, Free-list Allocator, Pool Allocator Visualized
In this video, we'll explore the complex but essential concept of memory allocation by taking it to the next dimension - 3D visualization. You'll witness how me...
How CPU Memory & Caches Work - Computerphile
Relatively speedy-to-access cache saves your computer having to trudge over to the RAM, but with multiple levels of cache memory, how does it all work?
Matt G...
How I Take Notes With Neovim (as a highschool student)
#latenightcoding #softwaredevelopment #coding
Check out byeAI here: https://byeai.dev
This is how I take notes entirely with Neovim (and a bunch of other tool...
BLAZINGLY FAST C++ Optimizations
Focuses on techniques for high-performance C++ code, aligning with software optimization and best practices.
raylib author on library internals and C programming language!
Ramon, the creator of raylib library, joins me to discuss its C code and design! We talk about open source model of development as well! Join us!
https://www.r...
uv: An Extremely Fast Python Package Manager
Charlie Marsh is the founder of Astral, which develops uv, a next-generation Python package manager written in Rust. In this talk, Charlie details the unique ch...
The ARC Prize 2024 Winning Algorithm
Daniel Franzen and Jan Disselhoff, the "ARChitects" are the official winners (with co-researcher David Hartmann) of the ARC Prize 2024. Filmed at Tufa Labs in Z...
Endgame: Big Tech Bytes the Dust - Jim Keller, Tenstorrent, Tesla, Apple, AMD, Intel #261
Jim Keller is a microprocessor engineer who has run the gauntlet of today’s leading tech companies during their peak performance years. He’s designed for Intel,...
Designing in 2023: 10 Problems to Solve w/ Jim Keller
"If you think something is unsolvable it will not get solved. Solving problems is partly about believing you can solve everything and sometimes that means you ...
[#39] DVUI - David Vanderson
Links:
https://david-vanderson.github.io/
Uploader: Zig SHOWTIME
Duration: 7990s
Views: 6579
Let's code math | Lean4 | Theorem prover
Continuous functions play a crucial role in various disciplines in math. We discuss the epsilon-delta criterion and formalize it in the programming language and...
Hierarchical Tiling to speed up my Matrix Multiplication
Support this channel at:
https://buymeacoffee.com/simonoz
Code for animations and examples:
https://github.com/SzymonOzog/GPU_Programming
https://github.com/Sz...
I Recreated Shazam's Algorithm from Scratch because no one is hiring jnr devs
I recreated Shazam's algorithm out of curiosity but mostly out of desperation. In this video, I explain how Shazam works and how I implemented the algorithm in ...
What Jim Keller Sees that Others Miss – DemystifySci #326
MAKE HISTORY WITH US THIS SUMMER:
https://demystifysci.com/demysticon-2025
PATREON
https://www.patreon.com/c/demystifysci
PARADIGM DRIFT
https://demystifysci...
One System, Eight Tenstorrent Wormholes
Everyone wants AI hardware to test and develop on, and Tenstorrent is leading the way from the AI startups when it comes to development kits. This new round of ...
61DAC Keynote: Jim Keller, CEO, Tenstorrent
Uploader: DACtv
Duration: 2568s
Views: 21759
Jim Keller on RISC-V Cores and Chiplets
Clip from my interview with Jim Keller: https://www.youtube.com/watch?v=YOiXomG9FhE
Subscribe to the TechTechPotato main channel at: http://www.youtube.com/tec...
RISC-V Day '23 Summer The Future of RISC-V and RISC-V AI (Jim Keller | CEO, Tenstorrent)
Audio Noise Removal Version / 音声ノイズ除去バージョン
0925 The Future of RISC-V and RISC-V AI Jim Keller | CEO, Tenstorrent (Canada)
0925 RISC-VとAIとの未来 Jim Keller (ジム・...
Rust is the New C
THE 70s MUST HAVE BEEN A WILD TIME TO BE ALIVE, right?
I often daydream about the lives of people who picked up C just at this perfect time, right at the start....
Code walkthrough of my game written in x64 assembly
Detailed code walk-through of a game engine in x64 assembly provides valuable low-level programming insight.
I can prove I’ve solved this Sudoku without revealing it
Clear, well-structured explanation of zero-knowledge proofs with examples—solid educational cryptography content.
RISC-V Technology Conference: Day 1 Keynotes | Nerds Talking to Nerds About RISC V
Watch the first half of Day 1 of our RISC-V Technology Conference in Bangalore.
Opening Remarks from Minister Rajeev Chandrasekhar
Keynote from Tenstorrent Inc...
The Genius of RISC-V Microprocessors - Erik Engheim - ACCU 2022
Join The ACCU Membership For Exclusive Benefits, Discounts & Reduced Conference Ticket Pricing:
https://accu.org/menu-overviews/membership/
---
The Genius of R...
Jim Keller's Initial Confidence in Tenstorrent
Clip from my interview with Jim Keller and Ljubisa Bajic of Tenstorrent
https://www.youtube.com/watch?v=sMvudTBBQNw
Subscribe to the TechTechPotato main channe...
Tenstorrent: Relegating the Important Stuff to the Compiler
Presented by Ljubisa Bajic, CEO and Lead Architect, and Stan Skokrac, VP Software, Tenstorrent
The machine learning field is red hot, and numerous teams have b...
The critical threshold in programming: 5 thousand lines of code | ThePrimeagen and Lex Fridman
Clip discusses cognitive and organizational issues around code size, offering insight into software engineering practices and maintainability.
Keynote: Development Environments Shape Programming Solutions - Stephanie Brenham - ACCU 2023
ACCU Membership: https://tinyurl.com/ydnfkcyn
Sponsored By think-cell: https://www.think-cell.com/accu
https://accu.org
Keynote: Development Environments Shape...
Not Your Grandparent's C++ - The Evolution of Cpp - Phil Nash - ACCU Cambridge
ACCU Membership: https://tinyurl.com/ydnfkcyn
Join us for ACCU Conference 2025 - 1st-4th April - Online & in Bristol, UK
https://accuconference.org/
---
Not Yo...
Live at NVIDIA GTC with Acquired
Hosted by the Acquired podcast, "Live at NVIDIA GTC With Acquired," this special pregame broadcast featured luminary speakers offering valuable insights into NV...
TSMC founder Morris Chang on the evolution of the semiconductor industry
As part of the Manufacturing@MIT Distinguished Speaker Series, Dr. Morris Chang SB ’52, SM ’53, ME ‘55, founder and former chairman and CEO of TSMC (Taiwan Semi...
Past, Present & Future of AI Compute (Panel) | Beyond CUDA Summit 2025
In this insightful panel, pioneering architects behind CUDA—including Gregory Diamos, Davor Capalija, Micah Villmow, and Nicholas Wilt—explore the rise of NVID...
AI Coding: Compute Shaders vs CUDA vs openCL - Dr. Fuhua (Frank) Cheng
Abstract: When every big company such as Microsoft, Amazon, Google, Meta, Apple, ..., is rushing to buy Nvidia GPUs to train and run their AI models, who are go...
NVIDIA Doesn't Care About GPUs
Interesting stuff coming out of NVIDIA's event. The Analyst Q&A with Jensen was particularly eye-opening.
[00:00] Keynotes
[01:49] Does NVIDIA Build GPUs Anymo...
The Exact Moment AMD Beat Intel
AMD Core Innovation Summit May 2014
Jim Keller, the architect behind the original Athlon 64 and Athlon XP talks about the exciting new Zen architecture that has...
What Every Programmer Should Know about How CPUs Work • Matt Godbolt • GOTO 2024
This presentation was recorded at GOTO Chicago 2024. #GOTOcon #GOTOchgo
https://gotochgo.com
Matt Godbolt - Low-level Latency Geek @MattGodbolt
RESOURCES
htt...
The Beauty of Simplicity - Making Your Own Technology • Yan Chernikov • YOW! 2024
This presentation was recorded at YOW! Australia 2024. #GOTOcon #YOW
https://yowcon.com
Yan Chernikov - Director at Studio Cherno @TheCherno
RESOURCES
https:...
Richard S. Sutton, Turing Award Winner | Approximately Correct
On this episode of Approximately Correct, we talk about Richard S. Sutton's AI journey and with his peers about his recent Turing Award.
Want to learn from AI ...
Amateurs Solve a Famous Computer Science Problem On Discord
A team of amateurs recently came together in an online collaboration called the Busy Beaver Challenge to pin down the value of BB(5), the fifth "busy beaver" nu...
The Past, Present & Future of Programming Languages • Kevlin Henney • GOTO 2024
Conference talk that surveys historical and emerging trends in programming languages, providing contextual and educational value for software engineers.
Getting Started with Multi-GPU Scaling: Distributed Libraries | NVIDIA GTC 2025
Scaling beyond a single GPU can be challenging, but it's not as hard as you might think! Join us on a journey exploring multi-GPU libraries that simplify the pr...
How to write a fast Softmax kernel
Support this channel at:
https://buymeacoffee.com/simonoz
Code for animations:
https://github.com/SzymonOzog/GPU_Programming
Code for kernels and benchmarks:
...
Physicist Dr. David Deutsch-Quantum Computing, Turing Machines, & Multiverses (THE SAAD TRUTH_1742)
We discuss quantum computing, Turing machines, multiverses, consilience, interdisciplinarity, and the state of academia among other fascinating topics.
David w...
Scott Aaronson | How Much Math Is Knowable?
Speaker: Scott Aaronson, Department of Computer Science, University of Texas, Austin
Title: How Much Math Is Knowable?
Abstract: Theoretical computer science ...
Zeroes and Ones: Into the Depths of Computation | Jim Keller | EP 272
James B. Keller is a microprocessor engineer best known for his work at AMD and Apple. He was the lead architect of the AMD K8 microarchitecture and was involve...
TPU V4 and Trends in Accelerator Hardware - Mike Hutton
Uploader: Spatial ML Seminar Series
Duration: 2746s
Views: 5364
"Propositions as Types" by Philip Wadler
The principle of Propositions as Types links logic to computation. At first sight it appears to be a simple coincidence---almost a pun---but it turns out to be ...
But what is quantum computing? (Grover's Algorithm)
Qubits, state vectors, and Grover's algorithm for search.
Instead of sponsored ad reads, these lessons are funded directly by viewers: https://3b1b.co/support
A...
Fujitsu’s New ARM Chip: Focused, Fast, and Unlike Anything Else
Concise technical analysis of a forthcoming ARMv9 CPU, covering micro-architectural features, packaging, and compiler strategy—highly relevant to computer-archi...
Grammars, parsing, and recursive descent
This video has a page on 0DE5 with exercises and resources
https://www.0de5.net/stimuli/a-reintroduction-to-programming/instructions-to-languages/grammars-parsi...
Intro to TT-Forge
TT-Forge is Tenstorrent’s MLIR-based compiler. Learn how TT-Forge integrates with our AI software stack, why we’re building on MLIR, and the features that make ...
System Design for Next-Gen Frontier Models — Dylan Patel, SemiAnalysis
Current and future hardware requirements for next generation frontier models.
Recorded live in San Francisco at the AI Engineer World's Fair. See the full sche...
The State of Silicon and the GPU Poors - with Dylan Patel of SemiAnalysis
If Charles Dickens was alive in 2024, A Tale of Two Cities might be the divide between the “GPU poor” and the “GPU rich”.
We mentioned these terms in some of o...
Stephen Wolfram | Computational Foundations of Everything
Talk kindly contributed by Stephen Wolfram in SEMF's 2024 Interdisciplinary Summer School:
https://semf.org.es/school2024
TALK ABSTRACT
A talk on the recent d...
Lecture 55: Modular’s unified device accelerator language
Slides: https://drive.google.com/file/d/1pIVJDkohQUt1ZawQvzzR7Wi3cRmyE8Pa/view?usp=sharing
Uploader: GPU MODE
Duration: 7991s
Views: 3087
Building a Debugger • Sy Brand & Tim Misiak • GOTO 2025
This interview was recorded for the GOTO Book Club. #GOTOcon #GOTObookclub
http://gotopia.tech/bookclub
Read the full transcription of the interview here:
http...
Developer Productivity, v2 with ThePrimeagen | Preview
Full Course:
Developer Productivity, v2: https://www.frontendmasters.com/courses/developer-productivity-v2/?utm_source=youtube&utm_medium=course_link&utm_campai...
Formalizing a proof in Lean using Github copilot and canonical
In this experiment, I took a statement in universal algebra that a collaborator of mine (Bruno Le Floch) on the Equational Theories Project had written a one-pa...
How the heck do you make a PCB?
Despite the informal Twitch-stream format, the content is a hands-on walkthrough of PCB design/fabrication, a valuable technical skill for hardware/embedded eng...
Mojo meets AMD MI300X: Modular GPU Kernel Hackathon Highlights 🔥
Highlights from the Modular GPU Kernel Hackathon! 💥
Developers gathered at AGI House to build cutting-edge Mojo kernels on AMD Instinct™ MI300X, from LLM traini...
Formalizing a proof in Lean using Claude and o4
Following on from the previous video at https://www.youtube.com/watch?v=cyyR7j2ChCI, I now attempt to formalize a different proof of the same assertion using th...
How the Rust Compiler Works, a Deep Dive
In this video, Daniel Cumming a formal verification engineer at Runtime Verification and Rust instructor at RareSkills explains how the Rust compiler works unde...
How I FOUND the Nsa's backdoor inside your Intel Cpu
In this series we hunt for the backdoor that the NSA allegedly uses in order to crack AES encryption. The backdoor is inside of Intel (and AMD) CPUs and today w...
Must Know Technique in GPU Computing | Episode 4: Tiled Matrix Multiplication in CUDA C
Tiled (general) Matrix Multiplication from scratch in CUDA C.
Code Repo: https://github.com/tgautam03/CUDA-C/tree/master/05_tiled_mat_mul
Notes: https://0mean1...
Watch: Writing a new programming language from scratch! (How hard can it be?)
Watch me start writing an entirely new #programming #language and #codegen from scratch! You can support my work at: http://patreon.com/renerebe https://github....
A Hundred PyTorch Backends: Mark Saroufim at the Modular GPU Kernel Hackathon
Conference talk detailing PyTorch backend architecture, custom ops, and performance tuning—highly relevant for deep-learning engineers and compiler enthusiasts.
Jonathan Blow on pattern matching and Option type
Uploader: NotImplemented
Duration: 717s
Views: 10124
How BAD Is Test Driven Development? - The Standup #6
Panel discussion by experienced developers on the merits and pitfalls of Test-Driven Development provides practical insights and real-world anecdotes valuable t...
How 1999 Quake 3 Teaches Elite Software Engineering
This video was sponsored by Brilliant.
To try everything Brilliant has to offer—free—for a full 30 days, visit https://brilliant.org/Tariq10x/ . You’ll also get...
Turning Portal 2 into a Web Server
I found a way to turn Portal 2 into a web server.
Thank you for watching!
This project is available on GitHub: https://github.com/p2r3/HTTPortal
Join our Disco...
Dylan Patel (SemiAnalysis) on Multi-Datacenter Training @ Decentralized AI Day 2025
SemiAnalysis' Dylan Patel presentatng on Multi-Datacenter Training at the Decentralized AI Day 2025 event hosted by Prime Intellect
Uploader: Prime Intellect AI...
Oxidise Your Command Line (2025 Edition)
It's been a little over 2 years since my last Oxidise your Command Line video, and so it's about time for an update!
Today I have 30 rust-powered command line ...
Ultimate NixOS Guide | Flakes | Home-manager
Discord server: https://discord.gg/AqHbaeK43b
Donations: https://ko-fi.com/vimjoyer
Code from the video: https://github.com/vimjoyer/flake-starter-config
Also...
What is PLUS times PLUS?
ERRATA:
• The "Church-Turing Thesis" is different from the "Church-Turing Theorem". The "theorem" is the claim which I discussed in the video- namely, that the ...
GTC 2022 - How CUDA Programming Works - Stephen Jones, CUDA Architect, NVIDIA
Come for an introduction to programming the GPU by the lead architect of CUDA. CUDA's unique in being a programming language designed and built hand-in-hand wit...
Intro to CUDA (part 4): Indexing Threads within Grids and Blocks
CUDA Teaching Center
Oklahoma State University ECEN 4773/5793
Uploader: Josh Holloway
Duration: 361s
Views: 40934
Nix explained from the ground up
Comprehensive tutorial explaining Nix package manager, deterministic builds, and related tooling, valuable for devops and reproducible development.
CUDA Mode Keynote | Andrej Karpathy | Eureka Labs
Andrej Karpathy shared the story of how he built llm.c and encouraged the audience to build more reference architectures that can fit in an LLMs context length....
Why Use C for UI Library? | Nic Barker
Nic Barker is a self-taught programmer who went from web development to building Clay, a fast UI layout library in C. We talk about how he got started, his jour...
Agentic Engineering in Action with Mitchell Hashimoto
Mitchell takes us through his AI workflow and we dive into a recent commit of his: https://github.com/ghostty-org/ghostty/commit/3de3f48faf830fe1326f44b08fb9f27...
Inside a Real High-Frequency Trading System | HFT Architecture
High-Frequency Trading System (HFT) are the bleeding edge of real-time systems — HFT architecture is designed for nanosecond-level execution, not just milliseco...
RISC-V and the CPU Revolution, Yunsup Lee, Samsung Forum
Open source has revolutionized software. Now it is hardware's turn. This talk will present today's chip design economics, introduce the free and open RISC-V ins...
Typst is pretty neat
*tl;dr: a programming language for documents*
James shares a bit about Typst as an excited newcomer to the 'documents as code' ecosystem, while simultaneously ...
Building precision machines is simple, until it isn't.
Go to https://www.pcbway.com for all your CNC machining needs, and make the hard parts simple.
A long overdue upgrade to the homemade CNC milling machine, amon...
Coding Adventure: Simulating Fluids
Let's try to convince a bunch of particles to behave (at least somewhat) like water.
Written in C# and HLSL, and running inside the Unity engine.
Source code:
...
Scaling Computing Performance Beyond the End of Moore’s Law: Song Han
Song Han, Associate Professor, MIT Electrical Engineering and Computer Science, on accelerating large language model and generative AI.
Han’s talk was part of ...
EXO 2
Speaker: Yuka Ikarashi
Uploader: GPU MODE
Duration: 4115s
Views: 1072
GOSIM CHINA 2024 - Nicholas Nethercote: Rust Compiler Overview
Uploader: GOSIM Foundation
Duration: 1700s
Views: 320
Gordon Moore: Behind the Ubiquitous Microchip
Gordon Moore, co-founder of Intel Corporation, to whom the term "Moore's Law" is attributed, speaks about the ubiquitous microchip. Series: "Frontiers of Knowle...
Declarative C++ - Ankur Satle - C++Online 2025
Conference talk presenting advanced C++ design techniques for declarative programming, directly relevant to professional software development.
Writing an own Terminal from Scratch in C
In this video, i'll show you how you would go about writing a terminal emulator from scratch in C, as it's hard to find similar content to this :)
You can get...
Dylan Patel: GPT4.5's Flop, Grok 4, Meta's Poaching Spree, Apple's Failure, and Super Intelligence
Dylan Patel breaks down the current chaos inside the world’s top AI companies. Dylan is the founder and CEO of SemiAnalysis, one of the best analyst firms cover...
How I Simulate Over a Million Persistent NPCs For My Procedural City
Developer devlog that dives into algorithmic and performance considerations for simulating large numbers of NPCs, providing practical insights into game-engine ...
Weathering Software Winter
Here are some of Devine's disjointed thoughts on the creation of a clean-slate computing stack based on the universal virtual machine strategy for digital prese...
Jonathan Blow - Jai Demo and Design Explanation (KEYNOTE) - Updated
#LambdaConf2025 took place in Estes Park Colorado this past May 12th and 13th.
UPCOMING EVENT:
The Ultimate Coder
Casting call: https://docs.google.com/forms/d...
Type Theory in Computer Science, Linguistics, Logic
Type theory is one of the central ideas in theoretical computer science and formal linguistics. But what is it, where did it come from, and how does it work? We...
Developing an application from scratch (Haskell Unfolder #46)
In this episode targeted at beginners, we show the end-to-end application development process, starting from an empty directory. We'll consider package configur...
BRYCE ADELSTEIN LELBACH - The C++ Execution Model
[C++ Under the Sea 2024 conference]
https://cppunderthesea.nl/
11th of October 2024
Video recording sponsored by think-cell: https://www.think-cell.com
[T...
FPGA in HFT Systems Explained | Why Reconfigurable Hardware Beats CPUs
Clear technical explanation of FPGA architecture and its use in low-latency HFT systems, fitting the hardware and systems design focus.
Luminal - Search-Based Deep Learning Compilers
Speaker: Joe Fioti
Uploader: GPU MODE
Duration: 4169s
Views: 1039
"An approach to computing and sustainability inspired from permaculture" by Devine Lu Linvega
In this session, I will explore some playful low-power, sometimes analog, computation systems and esoteric programming languages, designed to work offline, on s...
#22 Dylan Patel: China’s Robotics Dominance; AI Infrastructure Breakdown
Jordan Wolfe sits down with Dylan Patel, Founder and Chief Analyst at SemiAnalysis, a research and consulting firm specializing in semiconductor and other AI-in...
An Introduction to Functional Imperative Programming in Flix • Magnus Madsen • GOTO 2023
This presentation was recorded at GOTO Aarhus 2023. #GOTOcon #GOTOaar
https://gotoaarhus.com
Magnus Madsen - Assistant Professor at Aarhus University
RESOURCE...
The Death of Monads? Direct Style Algebraic Effects
The purpose of monads and their alternatives (old and new). For people who love monads, hate monads, and those who don’t get them.
Make FP click by joining “Ho...
Algebraic Effects from Scratch by Kit Langton
Kit Langton explores algebraic effects, emphasizing separating syntax from semantics. Kit demonstrates this through the Kyo library, discussing syntax and seman...
Intel’s Reign of Terror
Links:
- Patreon (Support the channel directly!): https://www.patreon.com/Asianometry
- X: https://twitter.com/asianometry
- Bluesky: https://bsky.app/profile/a...
The Birth, Boom and Bust of the Hard Disk Drive
Links:
- The Asianometry Newsletter: https://www.asianometry.com
- Patreon: https://www.patreon.com/Asianometry
- Threads: https://www.threads.net/@asianometry
...
Why the Soviet Computer Failed
In 1986, the Soviet Union had slightly more than 10,000 computers. The Americans had 1.3 million.
At the time of Stalin's death, the Soviet Union was the worl...
AT&T’s UNIX PC Failure
Links:
- Patreon (Support the channel directly!): https://www.patreon.com/Asianometry
- X: https://twitter.com/asianometry
- Bluesky: https://bsky.app/profile/a...
Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025
Casey Muratori's talk at BSC 2025.
Casey's links:
- https://ComputerEnhance.com/
- https://x.com/cmuratori/
BSC links:
- https://BetterSoftwareConference.com/...
Eiríkr Åsheim: Uxn: Permacomputing & Roguelikes
Will your favorite roguelikes still be playable in 20 years? How about 50? The Uxn/Varvara ecosystem is a radically simple, portable, and personal approach to c...
Dennis Gustafsson – Parallelizing the physics solver – BSC 2025
Conference talk detailing techniques for parallelizing a physics solver; highly relevant to concurrency and performance optimization in software engineering.
Lambda Calculus vs. Turing Machines (Theory of Computation)
Advait Shinde discusses the history of the theory of computation, delving into axiomatic thinking, Peano axioms, Turing Machines, Lambda Calculus, the Y Combina...
A Flock of Functions: Lambda Calculus and Combinatory Logic in JavaScript | Gabriel Lebec @ DevTalks
The Lambda Calculus is a tiny symbol manipulation system which suffices to compute anything Turing-computable. Thanks to this expressive power, LC is woven into...
Stephen Wolfram visits RWRI 20 (The Real World Risk Summer School, 2025)
The great Stephen Wolfram spends 2 hours discussing the ruliads and computational irreducibility at the Real World Risk Institute Summer School.
Uploader: N N T...
OpenAI's Stable Code 3B: A Game-Changer for Coding & Programming Tasks
SUBSCRIBE CHANNEL: https://bit.ly/AIInsightNews
-----------------
OpenAI has released Stable Code 3B, a new Large Language Model (LLM) designed for code complet...
The World's First Microprocessor: F-14 Central Air Data Computer
Historical deep-dive into the MP944 F-14 Central Air Data Computer and its claim as the first microprocessor, including architecture and programming model.
How do hardware timers work?
Explains how CPUs implement hardware timers, covering divider chains, counter registers, interrupts, and their use in precise timing control.
Quantum Computing - Hype vs. reality | Field Notes
As the race to build the world's first truly useful quantum computer intensifies, so too does the need for clear-eyed assessment. This Field Notes episode bring...
Donald Knuth: Algorithms, Complexity, and The Art of Computer Programming | Lex Fridman Podcast #62
Donald Knuth reflects on algorithmic analysis, computational complexity, and insights from The Art of Computer Programming.
Using Apple Vision Pro: What It’s Actually Like!
Everything you need to know about using Apple Vision Pro
Vision Pro Review: https://youtu.be/86Gy035z_KA
Apple's Forbidden words: https://youtu.be/kvN5_GXlg2Y?...
The Map of Quantum Computing - Quantum Computing Explained
Comprehensive survey of quantum computing principles, algorithms, physical qubit implementations, and engineering challenges in the field.
Quantum Computing for Computer Scientists
Introduces the quantum computing model to computer scientists, deriving qubits, gates, and Deutsch’s algorithm using linear-algebra formalisms.
Hardware and software [2024 edition]
Detailed walkthrough of a developer’s 2024 hardware and Linux software setup, offering practical insights into tooling and workflow valuable to software enginee...
Watch kernel developer do Linux kernel development ;-)
Live coding stream showing workflow, tooling, and patch submission process for Linux kernel maintenance and security back-porting.
Memristors for Analog AI Chips
Technical overview of memristor technology and its role in power-efficient analog in-memory computing for AI accelerators.
Grounded II: Making The Last of Us Part II
Feature-length documentary exposing the production pipeline, tools, and design decisions behind Naughty Dog’s The Last of Us Part II.
Marc Raibert: Boston Dynamics and the Future of Robotics | Lex Fridman Podcast #412
Marc Raibert is founder and former long-time CEO of Boston Dynamics, and recently Executive Director of the newly-created Boston Dynamics AI Institute. Please s...
How AI Discovered a Faster Matrix Multiplication Algorithm
Explains how DeepMind’s AlphaTensor discovered record-breaking tensor-decomposition algorithms that speed up matrix multiplication.
Jeff Dean (Google): Exciting Trends in Machine Learning
Jeff Dean reviews recent algorithmic and hardware advances enabling Gemini-class multimodal LLMs and highlights scientific applications.
Let's build the GPT Tokenizer
Andrej Karpathy codes a GPT Byte-Pair-Encoding tokenizer from scratch, dissecting Unicode handling and frequency-based merges.
1.2 - Racing Down the Slopes of Moore’s Law (Bram Nauta)
Keynote analyzes the limits of Moore’s Law scaling and advocates mixed-signal and ADC-centric approaches for power-efficient RF/digital design.
The hidden beauty of the A* algorithm
Demonstrates how consistent heuristics transform Dijkstra into the A* algorithm, with proofs, implementation tips, and geographic path-finding demos.
How does Groq LPU work? (w/ Head of Silicon Igor Arsovski!)
Deep technical interview on Groq’s Language Processing Unit architecture—single-cycle SIMD fabric, compiler stack, and network scaling versus GPUs.
Fine-tune LLMs - Line by line code example
Hands-on Jupyter notebook walks line-by-line through performing LoRA fine-tuning of a large language model using HuggingFace PEFT.
Intel's Crazy Plan for AI Chips IS WORKING! (Supercut)
Highlights from the #intel Foundry Direct Connect keynote presentation, featuring Sam Altman from #openai as well as the CEOs of Microsoft ( #msft stock ) and A...
How Particle Life emerges from simplicity
Shows how simple inter-particle attraction/repulsion rules give rise to complex “Particle Life” behaviors, with open-source code for experimentation.
WHY IS THE HEAP SO SLOW?
Join CodeCrafters and learn by creating your own: Redis, Git, Http server, Interpreter, Grep... in your favorite programming language:
https://app.codecrafters....
Is this the Future of Programming Languages?
Long-form hacking session explores building a toy language front-end targeting the QBE backend, illustrating SSA IR, parsing, and register allocation.
George Hotz | Programming | rewriting linearizer (tinygrad) | Day In The Life Of A Software Engineer
George Hotz refactors tinygrad’s linearizer, exposing low-level tensor compiler optimizations that map high-level ops to efficient GPU kernels.
How do CPUs read machine code? — 6502 part 2
Details how a 6502 CPU fetches and decodes machine instructions, covering control lines, micro-sequencing, and timing states at the transistor level.
Busy Beaver Turing Machines - Computerphile
The Busy Beaver game, pointless? Or a lesson in the problems of computability? - How do you decide if something can be computed or not?
Professor Brailsford's ...
Anthropic's Meta Prompt: A Must-try!
The Anthropic prompt is to help you create better prompts
MetaPrompt Colab: https://drp.li/8Odmv
Meta Prompt colab Original: https://colab.research.google.com/...
Building a Scripting Language in C - Floats
Live-coded tutorial on implementing float support in a C scripting language, directly relevant to compilers and systems programming.
Tmux has forever changed the way I write code.
Before tmux, I spent most of my time working in graphical editors and interfaces, and found working in the terminal difficult to do.
After moving to tmux and l...
Turn VIM into a full featured IDE with only one command
The number one question I get is to explain how I set up my development environment.
So, I decided to do a video on one of the key components of my setup. NVCh...
The perfect Neovim setup for Python
Neovim is perhaps the best editor in my opinion. When set up correctly, it can empower you to be productive, especially when writing python code.
I want to hel...
Edsger W. Dijkstra - The Power of Counting Arguments
The Power of Counting Arguments (Cadence Labs Distinguished Speaker Series, 16 January 2001)
Downloaded from
http://www.cs.utexas.edu/users/EWD/video-audio/vide...
Hardware SPI Continued - IO from Scratch - Part 7
This is the second half of the Hardware SPI video that would have been far too long. As such the beginning jumps strait into implementation, I usually try and s...
Learn how to design your own custom computer chips!
The Zero to ASIC Course covers everything you need to design your own chips.
Sign up to the newsletter - https://www.zerotoasiccourse.com/newsletter
Uploader: ...
Parsing Protobuf Like Never Before
Historically I have worked on many projects related to high-performance Protobuf, be that on the C++ runtime, on the Rust runtime, or on integrating UPB, the fastest Protobuf runtime, written by my colleague Josh Haberman.
Adventures In Message Passing (with Rust)
Single-producer/single-consumer (SPSC) queues are essential for achieving high throughput in real-time applications like telemetry ingestion, game loops, and...
Using Closure-style Traits to Simplify a Rust API
Some thoughts on API design with GATs from implementing a generic picker library
« systemd has been a complete, utter, unmitigated success
Eleven init systems enter, one init system leaves.
Solving Wordle with uv's dependency resolver
mildbyte.xyz
Augmented Vertex Block Descent (AVBD)
Vertex Block Descent is a fast physics-based simulation method that is unconditionally stable, highly parallelizable, and capable of converging to the implicit Euler solution.
Oberon (operating system) - Wikipedia
The Oberon System[3] is a modular, single-user, single-process, multitasking operating system written in the programming language Oberon.
A distributed systems reliability glossary
A list of key concepts for building and testing reliable distributed systems, with basic definitions and deep references.
The Rise and Fall of Urbit
During the 2020 Covid lockdowns, the privately owned realms of the internet became the obligatory venues for public life.
Optimize CPU performance with Instruments
Learn how to optimize your app for Apple silicon with two new hardware-assisted tools in Instruments. We'll start by covering how to...
DeepSeek Debrief: >128 Days Later – SemiAnalysis
SemiAnalysis is hiring an analyst in New York City for Core Research, our world class research product for the finance industry. Please apply here It’s been a bit over 150 days since the launc…
On Technical Challenges: Lock Free Programming
The Oxide Computer Company job application process1 asks applicants to answer a set of personal questions about their career and experiences.
100R - orca
Orca operates on a base of 36 increments. Operators using numeric values will typically also operate on letters and convert them into values as per the following table.
weathering software winter
While we are grateful to have had the opportunity to give this presentation, an event in 2025 has resulted in us distancing ourselves from the conference responsible for hosting this talk.
computing and sustainability
I first heard of Strange Loop a few years ago, the talk that introduced me to the conference was Programming Should Eat Itself by Nada Amin.
Inference in Agda
Agda is a wonderful language and its unification engines are exemplary, practical, improve over time and work predictably well.
Mathematics In Lean
—————SOURCES————————————————————————
Percolation – Béla Bollobás and Oliver Riordan
Cambridge University Press, New York, 2006.
Sixty Years of Percolation – Hugo Duminil-Copin
https://www.ihes.fr/~duminil/publi/2018ICM.pdf
Percolation – Geoffrey Grimmett
volume 321 of Grundlehren der Mathematischen Wissenschaften [Fundamental Principles of Mathematical Sciences]. Springer-Verlag, Berlin, second edition, 1999.
—————NOTES—————————————————————————
Note at 10:42 – The uniqueness of the infinite cluster is known for the d-dimenional lattice since the works of Aizenman, Kesten and Newman - [Uniqueness of the infinite cluster and continuity of connectivity functions for short and long range percolation (1987)] and Burton and Keane - [Density and uniqueness in percolation (1989)]. It does not hold in general: when the graph in question is a regular tree for example, there are always infinitely many clusters during the supercritical phase.
The two last results shown here are only known for site percolation (in which vertices are open or closed instead of edges) in the triangular lattice, where a scaling limit for the boundaries of critical clusters was proved to exist (more on that in the third note). It is believed that these results are universal, that is, valid in great generality for planar percolation processes near criticality.
The third result is from an appendix by Gábor Pete in the paper [Scaling limits for the threshold window: When does a monotone Boolean function flip its outcome? (2017)] by Ahlberg and Steif. Consider an n by n box, and the event where there exists a left-right crossing of said box. Recall the uniform coupling from the video: intuitively, the result is saying that the point at which this crossing emerges in the uniform coupling is with high probability inside an interval of size n^{-3/4} around 1/2.
The fourth result is saying that the average size of the cluster of the origin (or any other given point) goes to infinity as we let p approach the critical parameter like a specific power of the distance between p and p_c. This power is called a critical exponent. The existence of these exponents was proved by Smirnov and Werner in the paper [Critical exponents for two-dimensional percolation (2001)].
Note at 10:52 – Hugo Duminil-Copin has several major contributions to the study of processes arising in statistical physics, including Bernoulli percolation. Among his works on Ising and Ising-like processes we can cite [Random Currents and Continuity of Ising Model’s Spontaneous Magnetization (2015)] with Aizenman and Sidoravicius and [Sharp phase transition for the random-cluster and Potts models via decision trees (2019)] with Raoufi and Tassion.
Note at 12:38 – In the triangular lattice site percolation, Stanislav Smirnov proved the conformal invariance of crossing probabilities at criticality (see https://www.unige.ch/~smirnov/papers/icmp-final.pdf for an overview), which led to the proof of the existence of scaling limits of exploration curves as Schramm–Loewner evolution processes. See [Critical percolation in the plane (2009)] by Smirnov. This provided a deep understanding of the critical phase in the triangular lattice site percolation, which to this day is not extended to the square lattice.
Note at 17:52 – It is not at all obvious that the probability of being connected to infinity is continuous above criticality. This result can be proved in the d-dimenional hypercubic lattices using the uniqueness of the infinite cluster, and more generally it was proved for transitive graphs (intuitively, graphs in which all vertices look the same) by Häggström, Peres and Schonmann in [Percolation on transitive graphs as a coalescent process: Relentless merging followed by simultaneous uniqueness (1999)].
—————SECTIONS———————————————————————
0:00 Introduction
1:37 Definition – Bernoulli Percolation
5:23 Definition – Uniform Coupling
7:56 Exploration – High-Resolution Square Grid
9:40 Exploration – Questions and Kesten's Theorem
10:58 Exploration – Ising Model
11:54 Exploration – Critical Percolation
12:50 Exploration – Three-Dimensional Cubic Lattice and Beyond
14:13 Proof – Theorem Statement
15:14 Proof – Simplifications
16:29 Proof – Definition of Critical Parameter
18:41 Proof – Critical Parameter is Greater Than Zero
20:44 Proof – Duality Definition
21:56 Proof – Critical Parameter is Less Than One
25:16 Proof – Summary and Idea for Kesten's Theorem
26:11 Conclusion
—————CREDITS————————————————————————
Caio Alves – writing, 3D animation
Aranka Hrušková – writing, clarinet
Vilas Winstein – writing, 2D animation, editing, voice-over
Special thanks to Anisah Awad, Gábor Pete, Jyotsna Sreenivasan, Angie Zavala
This video is an entry in the second Summer of Mathematics Exposition (#SoME2)
The photographs used in this video are licensed under the Creative Commons Attribution-ShareAlike license:
https://creativecommons.org/licenses/by-sa/4.0/deed.en
Uploader: Spectral Collective
Duration: 1612s
Views: 455517
Mechanical Watch: Exploded View
In May 2022, someone posted to Hacker News Bartosz Ciechanowski's blog post explaining how mechanical watch movements work. Since then, his blog has been my absolute favorite corner of the Internet.
My notes while reading about GPUs
I had a bunch of notion pages in which I had written some notes while reading and watching videos on GPUs for CUDA purpose so thought of doing vibe blogging ...
To B or not to B: B-Trees with Optimistic Lock Coupling
CedarDB is a database system that delivers unmatched performance for transactions and analytics, from small writes to handling billions of rows. Built on cutting-edge research to power today’s tools and tomorrow’s challenges.
TeX and Typst: Layout Models
An exploration of the layout models of TeX and Typst.
David A. Wheeler's Review of Debugging by David J. Agans
It's not often you find a classic, but I think I've found a new classic for software and computer hardware developers. It's David J.
Taking a Look at Compression Algorithms
Dissecting various compression algorithms.
How we built our multi-agent research system
On the the engineering challenges and lessons learned from building Claude's Research system
An MLIR Dialect for Distributed Heterogeneous Computing
Welcome to the home page of the 46th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2025)!
PLDI is the premier forum in the field of programming languages and programming systems research, covering the areas of design, implementation, theory, applications, and performance.
PLDI 2025 will be held in-person at the Westin Josun Seoul in Seoul, South Korea.
The main PLDI conference will be held Wednesday, 18 June through Friday, 20 June. Workshops and tutorials were held on Monday, 16 June and Tuesday, 17 June.
PLDI 2025 Travel Guide
Nuno Lopes has kindly writte ...
Why Resonate
There are lot of reasons why you should consider adopting Resonate.
TPU Deep Dive
Their origins go back to Google in 2006, when they were first evaluating whether they should implement either GPUs, FPGAs, or custom ASICs.
Tiger Style
A coding philosophy focused on safety, performance, and developer experience.
LazyLog: A New Shared Log Abstraction for Low-Latency Applications
Shared logs offer linearizable total order across storage shards. However, they enforce this order eagerly upon ingestion, leading to high latencies.
Consistency Models
This clickable map (adapted from Bailis, Davidson, Fekete et al and Viotti & Vukolic) shows the relationships between common consistency models for concurrent systems.
Convex is the open-source reactive database for app developers.
Convex is the reactive database for app developers. Everything you need to build your full-stack project.
Domain specific architectures for AI inference
fleetwood.dev
Optimizing Transformer-Based Diffusion Models for Video Generation with NVIDIA TensorRT
State-of-the-art image diffusion models take tens of seconds to process a single image. This makes video diffusion even more challenging, requiring significant computational resources and high costs.
The Curse of Knowing How, or; Fixing Everything
A reflection on control, burnout, and the strange weight of technical fluency.
a Hugging Face Space by nanotron
The ultimate guide to training LLM on large GPU Clusters
A Guide on Semiconductor Development
How It's Made: Fancy Sand
ARM's Chernobyl Moment
Incredibly self-destructive cancelation of Qualcomm's v8 ALA.
The Book of Shaders
Gentle step-by-step guide through the abstract and complex universe of Fragment Shaders.
Unstructured Thoughts on the Problems of OSS/FOSS
Originally from replies to a Twitter thread: https://x.com/TheGingerBill/status/1914389352416993395
This is not a structured argument against FOSS/OSS but my uncommon thoughts on the topic.
I am not sure if I agree [that FOSS/OSS derives from the same thinking process as the ideology of communism], but I understand the sentiment. The fundamental issue is that software is trivially copyable. I have loads of issues with FOSS and OSS1. And part of this “ideology” (as presented in the original post) is naïvety coupled with only first-order thinking and a poor understanding of ownership.
On Bloat
On Bloat Rob Pike Brighter Tech Commonwealth Bank September 30, 2024
tt-metal/tech_reports/memory/allocator.md at main · tenstorrent/tt-metal
:metal: TT-NN operator library, and TT-Metalium low level kernel programming model. - tenstorrent/tt-metal
Memory on Tenstorrent
When I first started programming Metalium. Memory was a
Subnanosecond flash memory enabled by 2D-enhanced hot-carrier injection
A two-dimensional Dirac graphene-channel flash memory based on a two-dimensional-enhanced hot-carrier-injection mechanism that supports both electron and hole injection is used to make devices with a subnanosecond program speed.
A Gentle Introduction to Lambda Calculus - Part 1: Syntax
Even though lots of people nowadays advocate for applying functional programming principles to JavaScript, not many of them know the principles of Lambda Cal...
Getting Started
Yet it seems to me that the situation right now is that LtU has readers with very different backgrounds, among them many readers who haven't studied PL formally.
Mission Apollo: Landing Optical Circuit Switching at Datacenter Scale
In this paper, we describe Apollo, to the best of our knowledge, the world's
first large-scale production deployment of optical circuit switches (OCSes) for
datacenter networking. We will first describe the infrastructure challenges and
use cases that motivated optical switching inside datacenters. We then delve
into the requirements of OCSes for datacenter applications: balancing cost,
port count, switching time, and optical performance, which drive design choices
and implementation details of our internally developed 3D MEMS-based OCS. To
enable the Apollo optical switching layer, we employ circulators to realize
bidirectional links through the OCS, effectively doubling the OCS radix. The
OCS and circulator design choices were critical for meeting network bandwidth,
scale, and cost targets. We review the critical co-design of WDM transceiver
technology for these OCS plus circulator-based bidirectional links and their
corresponding physical impairments, delivered over four generations/speeds of
optical interconnect. Finally, we conclude with thoughts on future directions
in hardware development and associated applications.
Building an Open Future
We are building an open future for AI. Own your silicon future. Join us.
Faking ADTs and GADTs in Languages That Shouldn't Have Them
Haskell is the world’s best programming language, but let’s face the harsh reality that a lot of times in life you’ll have to write in other programming languages. But alas you have been fully Haskell-brained and lost all ability to program unless it is type-directed, you don’t even know how to start writing a program without imagining its shape as a type first. Well, fear not. The foundational theory behind Algebraic Data Types and Generalized Algebraic Data Types (ADTs and GADTs) are so fundamental that they’ll fit (somewhat) seamlessly into whatever language you’re forced to write. After all, if they can fit profunctor optics in Microsoft’s Java code, the sky’s the limit! This is an “April Fools” joke in the tradition of my previous one in some of these ways that we are going to twist these other languages might seem unconventional or possibly ill-advised… but also the title is definitely a lie: these languages definitely should have them! :D
Accelerate
Accelerate is a language for array-based computations, designed to exploit massive parallelism.
Ok Rust, You Really Have a Readability Problem
Rust is safe. Rust is fast. Rust is powerful. And Rust is… sometimes completely unreadable.
Things that go wrong with disk IO
Things that go wrong with disk IO
Analyzing Modern NVIDIA GPU cores
GPUs are the most popular platform for accelerating HPC workloads, such as artificial intelligence and science simulations. However, most microarchitectural research in academia relies on GPU core pipeline designs based on architectures that are more than 15 years old.
This paper reverse engineers modern NVIDIA GPU cores, unveiling many key aspects of its design and explaining how GPUs leverage hardware-compiler techniques where the compiler guides hardware during execution. In particular, it reveals how the issue logic works including the policy of the issue scheduler, the structure of the register file and its associated cache, and multiple features of the memory pipeline. Moreover, it analyses how a simple instruction prefetcher based on a stream buffer fits well with modern NVIDIA GPUs and is likely to be used. Furthermore, we investigate the impact of the register file cache and the number of register file read ports on both simulation accuracy and performance.
By modeling all these new discovered microarchitectural details, we achieve 18.24% lower mean absolute percentage error (MAPE) in execution cycles than previous state-of-the-art simulators, resulting in an average of 13.98% MAPE with respect to real hardware (NVIDIA RTX A6000). Also, we demonstrate that this new model stands for other NVIDIA architectures, such as Turing. Finally, we show that the software-based dependence management mechanism included in modern NVIDIA GPUs outperforms a hardware mechanism based on scoreboards in terms of performance and area.
Advanced Performance Optimizations for Models
:metal: TT-NN operator library, and TT-Metalium low level kernel programming model. - tenstorrent/tt-metal
Move Slow and Fix Things
Growing up as a kid in rural Bavaria, I always …
Why is Yazi fast?
This article assumes that you have already used Yazi and are familiar with most of its features.
User Guide for NVPTX Back-end
To support GPU programming, the NVPTX back-end supports a subset of LLVM IR along with a defined set of conventions used to represent GPU programming concepts.
An AnandTech Interview with Jim Keller: 'The Laziest Person at Tesla'
I've spoken about Jim Keller many times on AnandTech.
Notes/Primer on Clang Compiler Frontend (1) : Introduction and Architecture
Notes/Primer on Clang Compiler Frontend: Introduction and Architecture
These are my notes on chapters 1 & 2 of the Clang Compiler Frontend by Ivan Murashko. The book is focused on teaching the fundamentals of LLVM to C++ engineers who are interested in learning about compilers to optimize their daily workflow by enhancing their code quality and overall development process. (I’ve referened this book extensively, and a lot of the snippets here are from this book.
Implementation of simple microprocessor using verilog
I am trying to make a simple microprocessor in verilog as a way to understand verilog and assembly at the same time.
I am not sure if I am implementing what I think of microprocessors well enough ...
learn-fpga/FemtoRV/TUTORIALS/FROM_BLINKER_TO_RISCV/README.md at master · BrunoLevy/learn-fpga · GitHub
Learning FPGA, yosys, nextpnr, and RISC-V . Contribute to BrunoLevy/learn-fpga development by creating an account on GitHub.
Why async Rust?
I genuinely can’t understand how anybody could look at the mess that’s Rust’s async and think that it was a good design for a language that already had the reputation of being very complicated to write.
Template Haskell
Intuitively Template Haskell provides new language features that allow us to convert back and forth between concrete syntax, i. e.
A friendly introduction to machine learning compilers and optimizers
[Twitter thread, Hacker News discussion]
Comments on Source
The section of the wiki allows anyone to document, explain, post questions, or make comments on the Lua source code. You may link to [1] or paste the code in question.
The Making of Python
Guido van Rossum is the author of Python, an interpreted, interactive object-oriented programming language.
tt-metal/METALIUM_GUIDE.md at main · tenstorrent/tt-metal · GitHub
:metal: TT-NN operator library, and TT-Metalium low level kernel programming model. - tenstorrent/tt-metal
Scoping out the Tenstorrent Wormhole
The Tenstorrent Wormhole n300s PCIe accelerator board is available for purchase, featuring 672 RISC-V cores driving 466 TFLOP/s of FP8 matmul.
What’s the (floating) Point of all these data types? A (not so) brief overview of the history and usage of datatypes within the wide world of computation
This presentation delves into the fascinating and sometimes aggravating world of numerical data types, exploring the evolution, strengths, and weaknesses of decimal, fixed point, floating point, and shared exponent formats over the past 70 years.
Tenstorrent first thoughts
I've looked into alternative AI accelerators to continue my saga of running GGML on lower power-consumption hardware. The most promising - and the only one that ever replied to my emails - was Tenstorrent. This post is me deeply thinking about if buying their hardware for development is a good inve ...
CFD Python: 12 steps to Navier-Stokes
We announce the public release of online educational materials for self-learners of CFD using IPython Notebooks: the CFD Python Class!
tt-mlir documentation
The following document provides an overview of the TT-MLIR project, with a focus on the technical specifications of an MLIR-based compiler stack. So what exactly is an MLIR-based compiler stack?
Tutorials
Multi-Level IR Compiler Framework
Yizhou Shan's Home Page
This paper has a really nice Intro, pay close attention to how they lay out the storyline.
How to Think About TPUs
All about how TPUs work, how they're networked together to enable multi-chip training and inference, and how they limit the performance of our favorite algorithms. While this may seem a little dry, it's super important for actually making models efficient.
Programming Really Is Simple Mathematics
A re-construction of the fundamentals of programming as a small mathematical theory (PRISM) based on elementary set theory. Highlights:
$\bullet$ Zero axioms. No properties are assumed, all are proved (from standard set theory).
$\bullet$ A single concept covers specifications and programs.
$\bullet$ Its definition only involves one relation and one set.
$\bullet$ Everything proceeds from three operations: choice, composition and restriction.
$\bullet$ These techniques suffice to derive the axioms of classic papers on the "laws of programming" as consequences and prove them mechanically.
$\bullet$ The ordinary subset operator suffices to define both the notion of program correctness and the concepts of specialization and refinement.
$\bullet$ From this basis, the theory deduces dozens of theorems characterizing important properties of programs and programming.
$\bullet$ All these theorems have been mechanically verified (using Isabelle/HOL); the proofs are available in a public repository.
This paper is a considerable extension and rewrite of an earlier contribution [arXiv:1507.00723]
Tenstorrent Wormhole Series Part 1: Physicalities
A company called Tenstorrent design and sell PCIe cards for AI acceleration. At the time of writing, they've recently started shipping their Wormhole n150s and Wormhole n300s cards.
Community Highlight: Tenstorrent Wormhole Series Part 2: Which disabled rows?
An in depth look at Tenstorrent Wormhole, originally posted on corsix.org
Automating GPU Kernel Generation with DeepSeek-R1 and Inference Time Scaling
As AI models extend their capabilities to solve more sophisticated challenges, a new scaling law known as test-time scaling or inference-time scaling is emerging. Also known as AI reasoning or long…
Build Your Own Text Editor
The text editor is antirez’s kilo, with some changes.
Tilde, my LLVM alternative
I'm Yasser and I've made it my mission to produce an alternative to LLVM, the current king of compiler backend libraries.
A WebAssembly compiler that fits in a tweet
Starting with a 192-byte one-liner that implements a Reverse Polish Notation arithmetic compiler, we'll work backward to transform it into readable JavaScript by removing one code golf trick at a time
Stating the problem in Lean
Note: this post was written for Lean 3; the latest version, Lean 4, is a very different language.
Turn back the clock to 2009: a confused physics major newly infatuated with math and computer science, I enrolled in MATH 273: Numbers and Proofs at the University of Calgary. This wasn’t my first encounter with mathematical proof; in first-year calculus I’d mastered rote regurgitation of delta-epsilon proofs. Despite writing out several dozen, their meaning never progressed beyond a sort of incantation I can summon to this day (for every \( \epsilon > 0 \) there exists a \( \delta > 0 \) such that…).
Why Futhark?
A high-performance and high-level purely functional data-parallel array programming language that can execute on the GPU and CPU.
gcvsmalloc
—————SOURCES————————————————————————
Percolation – Béla Bollobás and Oliver Riordan
Cambridge University Press, New York, 2006.
Sixty Years of Percolation – Hugo Duminil-Copin
https://www.ihes.fr/~duminil/publi/2018ICM.pdf
Percolation – Geoffrey Grimmett
volume 321 of Grundlehren der Mathematischen Wissenschaften [Fundamental Principles of Mathematical Sciences]. Springer-Verlag, Berlin, second edition, 1999.
—————NOTES—————————————————————————
Note at 10:42 – The uniqueness of the infinite cluster is known for the d-dimenional lattice since the works of Aizenman, Kesten and Newman - [Uniqueness of the infinite cluster and continuity of connectivity functions for short and long range percolation (1987)] and Burton and Keane - [Density and uniqueness in percolation (1989)]. It does not hold in general: when the graph in question is a regular tree for example, there are always infinitely many clusters during the supercritical phase.
The two last results shown here are only known for site percolation (in which vertices are open or closed instead of edges) in the triangular lattice, where a scaling limit for the boundaries of critical clusters was proved to exist (more on that in the third note). It is believed that these results are universal, that is, valid in great generality for planar percolation processes near criticality.
The third result is from an appendix by Gábor Pete in the paper [Scaling limits for the threshold window: When does a monotone Boolean function flip its outcome? (2017)] by Ahlberg and Steif. Consider an n by n box, and the event where there exists a left-right crossing of said box. Recall the uniform coupling from the video: intuitively, the result is saying that the point at which this crossing emerges in the uniform coupling is with high probability inside an interval of size n^{-3/4} around 1/2.
The fourth result is saying that the average size of the cluster of the origin (or any other given point) goes to infinity as we let p approach the critical parameter like a specific power of the distance between p and p_c. This power is called a critical exponent. The existence of these exponents was proved by Smirnov and Werner in the paper [Critical exponents for two-dimensional percolation (2001)].
Note at 10:52 – Hugo Duminil-Copin has several major contributions to the study of processes arising in statistical physics, including Bernoulli percolation. Among his works on Ising and Ising-like processes we can cite [Random Currents and Continuity of Ising Model’s Spontaneous Magnetization (2015)] with Aizenman and Sidoravicius and [Sharp phase transition for the random-cluster and Potts models via decision trees (2019)] with Raoufi and Tassion.
Note at 12:38 – In the triangular lattice site percolation, Stanislav Smirnov proved the conformal invariance of crossing probabilities at criticality (see https://www.unige.ch/~smirnov/papers/icmp-final.pdf for an overview), which led to the proof of the existence of scaling limits of exploration curves as Schramm–Loewner evolution processes. See [Critical percolation in the plane (2009)] by Smirnov. This provided a deep understanding of the critical phase in the triangular lattice site percolation, which to this day is not extended to the square lattice.
Note at 17:52 – It is not at all obvious that the probability of being connected to infinity is continuous above criticality. This result can be proved in the d-dimenional hypercubic lattices using the uniqueness of the infinite cluster, and more generally it was proved for transitive graphs (intuitively, graphs in which all vertices look the same) by Häggström, Peres and Schonmann in [Percolation on transitive graphs as a coalescent process: Relentless merging followed by simultaneous uniqueness (1999)].
—————SECTIONS———————————————————————
0:00 Introduction
1:37 Definition – Bernoulli Percolation
5:23 Definition – Uniform Coupling
7:56 Exploration – High-Resolution Square Grid
9:40 Exploration – Questions and Kesten's Theorem
10:58 Exploration – Ising Model
11:54 Exploration – Critical Percolation
12:50 Exploration – Three-Dimensional Cubic Lattice and Beyond
14:13 Proof – Theorem Statement
15:14 Proof – Simplifications
16:29 Proof – Definition of Critical Parameter
18:41 Proof – Critical Parameter is Greater Than Zero
20:44 Proof – Duality Definition
21:56 Proof – Critical Parameter is Less Than One
25:16 Proof – Summary and Idea for Kesten's Theorem
26:11 Conclusion
—————CREDITS————————————————————————
Caio Alves – writing, 3D animation
Aranka Hrušková – writing, clarinet
Vilas Winstein – writing, 2D animation, editing, voice-over
Special thanks to Anisah Awad, Gábor Pete, Jyotsna Sreenivasan, Angie Zavala
This video is an entry in the second Summer of Mathematics Exposition (#SoME2)
The photographs used in this video are licensed under the Creative Commons Attribution-ShareAlike license:
https://creativecommons.org/licenses/by-sa/4.0/deed.en
Uploader: Spectral Collective
Duration: 1612s
Views: 455517
Bloom filters debunked: Dispelling 30 Years of bad math with Coq!
While conceptually simple, this feature actually requires more engineering effort than one would expect - in particular, tracking the set of known malicious URLs in a practical manner turns out to be somewhat difficult.
The Double-E Infix Expression Parsing Method
Topic in Programming Models
Demystifying Debuggers, Part 2: The Anatomy Of A Running Program
On the concepts involved in a running program. What happens, exactly, when you double click an executable file, or launch it from the command line, and it begins to execute?
FPGAs for Software Engineers 0: The Basics
A brief introduction to FPGAs, Verilog and simulation
Data-Oriented Design
Data-Oriented Design
A note about "The Humane Representation of Thought"
A year and a half ago, on a plane, I wrote An Ill-Advised Personal Note about "Media for Thinking the Unthinkable".
On Ousterhout’s Dichotomy Oct 6, 2024
Why are there so many programming languages? One of the driving reasons for this is that some
languages tend to produce fast code, but are a bit of a pain to use (C++), while others are a breeze
to write, but run somewhat slow (Python). Depending on the ratio of CPUs to programmers, one or the
other might be relatively more important.
The categorical abstract machine
The Cartesian closed categories have been shown by several authors to provide the right framework of the model theory of λ-calculus. The second author…
Logical Complexity of Proofs
If you cannot find proofs, talk about them. Robert Reckhow with his advsior Stephen Cook famously started the formal study of the complexity of proofs with their 1979 paper. They were interested in…
What is the "question" that programming language theory is trying to answer?
I've been interested in various topics like Combinatory Logic, Lambda Calculus, Functional Programming for a while and have been studying them. However, unlike the "Theory of Computation" which str...
Introducing Limbo: A complete rewrite of SQLite in Rust
we forked SQLite with the libSQL project. What would it be like if we just rewrote it?
TLA+ is hard to learn
I’m a fan of the formal specification language TLA+. With TLA+, you can build models of programs or systems, which helps to reason about their behavior. TLA+ is particularly useful for reason…
How hard is constraint programming?
Writing code using the Z3 SMT solver is different from typical programming, due to mixed programming models--not unlike CUDA for GPUs. Here's what to expect.
Advanced programming languages
Students often ask for a recommendation on what language they should learn next.
GitHub - avinassh/py-caskdb: (educational) build your own disk based KV store
(educational) build your own disk based KV store. Contribute to avinassh/py-caskdb development by creating an account on GitHub.
Command Line Interface Guidelines
An open-source guide to help you write better command-line programs, taking traditional UNIX principles and updating them for the modern day.
How Many Computers Are In Your Computer?
Any ‘computer’ is made up of hundreds of separate computers plugged together, any of which can be hacked. I list some of these parts.
Genie 2: A large-scale foundation world model
Generating unlimited diverse training environments for future general agents
Design Of This Website
Meta page describing Gwern.net, the self-documenting website’s implementation and experiments for better ‘semantic zoom’ of hypertext; technical decisions using Markdown and static hosting.
Fastest contributed programs, grouped by programming language implementation
Charts showing benchmark program performance grouped by implementation language.
Haskell as fast as C: working at a high altitude for low level performance
After the last post about high performance, high level programming, Slava Pestov, of Factor fame, wondered whether it was generally true that “if you want good performance you have to write C…
On Competing with C Using Haskell
Mark Karpov wrote in his article on Migrating text metrics to pure Haskell how he originally did foreign calls out to C for many of the functions in his text metric package, but now ported them to Haskell when he learned that Haskell can give you performance comparable to C.
Performance
Moreover, it's often not clear if two programs which supposedly have the same functionality really do the same thing.
Introducing io_uring_spawn
The traditional mechanism for launching a program in a new process on Unix systems—forking and execing—has been with us for decades, but it is not really the most efficient of operations.
Daniel Lemire's blog
I find that there can still be a significant benefit to using csFastFloat over the . NET library: it can be about 3 times faster.
A Beginner's Guide to Vectorization By Hand: Part 3
We're continuing our expendition to the world of manual vectorization. In this part, we will explain the most common technique for vectorizing conditional code (usually referred as if-conversion).
Competitive Programming
This is the supporting web page for a book titled: "Competitive Programming 4: The Lower Bound of Programming Contests in the 2020s" written by Steven Halim, Felix Halim, and Suhendry Effendy.
MOND←TECH MAGAZINE
This is a website, which means it sometimes goes offline
Algorithms for Modern Hardware
Its intended audience is everyone from performance engineers and practical algorithm researchers to undergraduate computer science students who have just finished an advanced algorithms course and want to learn more practical ways to speed up a program than by going from O(nlogn) to O(nloglogn).
Creating enums at comptime
Using zig's @Type to dynamically create enums at comptime
Zig's new declaration literals
A look at Zig's new declaration literals
Zig's (.{}){} syntax
A look at some unfriendly Zig syntax
How LLVM Optimizes a Function
In some compilers the IR format remains fixed throughout the optimization pipeline, in others the format or semantics change.
How 99% of C Tutorials Get it Wrong
But this article did not arise only from my own opinion. The argument I'll present here, at least in its general form, is one which programmers who I know personally and I admire a lot (e.
A Beginner's Guide to Vectorization By Hand: Part 1
The CPU vendors have been trying for a lot of time to exploit as much parallelism as they can and the introduction of vector instructions is one way to go.
Tell the Compiler What You Know
Compilers a lot of times use magic to uncover hidden mysteries of your program and optimize it aggressively.
Compiler Optimization in a Language you Can Understand
In this article, I'll explain compiler optimizations through a series of examples, focusing on what compilers do.
How Target-Independent is Your IR?
An esoteric exploration on the target independence of compiler IRs.
For Beginners
Occasional writings about Haskell.
Oasis: A Universe in a Transformer
Generating Worlds in Realtime
A Fat Pointer Library
libCello Official Website
The Basics
Here’s what I consider to be the basics.
TCP Server in Zig - Part 5a - Poll
Using non-blocking sockets and poll to improve the scalability of our system.
6.824 Schedule: Spring 2022
Here is the tentative schedule of lectures and due dates. The lecture notes and paper questions for future dates are copies from previous years, and may change.
Typing the technical interview
In the formless days, long before the rise of the Church, all spells were woven of pure causality, all actions were permitted, and death was common.
Reversing the technical interview
If you want to get a job as a software witch, you’re going to have to pass a whiteboard interview.
Hexing the technical interview
But Hacker News has read of you, in their snicker-slithing susurrential warrens, and word has spread, which is why the young man offering you a smörgåsbord of microkitchen delights looks mildly suspicious already.
Nine Rules for SIMD Acceleration of Your Rust Code (Part 1)
General Lessons from Boosting Data Ingestion in the range-set-blaze Crate by 7x
B-trees and database indexes
B-trees are used by many modern DBMSs. Learn how they work, how databases use them, and how your choice of primary key can affect index performance.
Safe C++
Over the past two years, the United States Government has been issuing warnings about memory-unsafe programming languages with increasing urgency.
Async Rust can be a pleasure to work with (without `Send + Sync + 'static`)
Async Rust is powerful. And it can be a pain to work with (and learn). Async Rust can be a pleasure to work with, though, if we can do it without `Send + Sync + 'static`.
Zig's BoundedArray
A quick look at how and why to use Zig's BoundedArray.
Linus Torvalds talks AI, Rust adoption, and why the Linux kernel is 'the only thing that matters'
In a wide-ranging conversation with Verizon open-source officer Dirk Hohndel, 'plodding engineer' Linus Torvalds discussed where Linux is today and where it may go tomorrow.
Intercepting and modifying Linux system calls with ptrace
Intercepting and modifying Linux system calls with ptrace
What's the big deal about Deterministic Simulation Testing?
What's the big deal about Deterministic Simulation Testing?
Zig and Emulators
Some quick Zig feedback in the context of a new 8-bit emulator project I starteda little while ago:
Linkers part 1
I’ve been working on and off on a new linker.
A ToC of the 20 part linker essay
I release this message (the ToC and comments) into the public domain, no right reserved.
`zig cc`: a Powerful Drop-In Replacement for GCC/Clang
If you have heard of Zig before, you may know it as a promising new programming language which is ambitiously trying to overthrow C as the de-facto systems language.
Zig Build System
The fundamental commands zig build-exe, zig build-lib, zig build-obj, and zig test are often sufficient.
Resources for Amateur Compiler Writers
I know complete pans of the literature are left out, but this is a page for amateur compiler writers. Anything that I did not find practical is not listed here.
MattPD/cpplinks: A categorized list of C++ resources.
A categorized list of C++ resources. Contribute to MattPD/cpplinks development by creating an account on GitHub.
Putting the “You” in CPU
Curious exactly what happens when you run a program on your computer? Learn how multiprocessing works, what system calls really are, how computers manage memory with hardware interrupts, and how Linux loads executables.
How to Compile Your Language
The guide also covers how to create a platform-specific executable with the help of the LLVM compiler infrastructure, which all of the previously mentioned languages use for the same purpose.
Introduction to the Odin Programming Language
Preface This article is an introduction the Odin Programming Language. It is aimed at people who know a bit of programming, but have never touched Odin. It is not a reference guide, rather I try to keep things informal and talk about what I think are important aspects of the language. There will be some notes on differences to C/C++, as Odin in many ways tries to be better C. If you enjoy this article and want to support me, then you can do so by becoming a patron.
Arena allocator tips and tricks
Over the past year I’ve refined my approach to arena allocation. With practice, it’s effective, simple, and fast; typically as easy to use as garbage collection but without the costs.
bytecode interpreters for tiny computers
I've previously come to the conclusion that there's little reason for using bytecode in the modern world, except in order to get more compact code, for which it can be very effective.
How I built zig-sqlite
When you prepare a statement zig-sqlite creates a brand new type only for this prepared statement.
The Hunt for the Missing Data Type
A (directed) graph is a set of nodes, connected by arrows (edges). The nodes and edges may contain data. Here are some graphs:
All graphs made with graphviz (source)
Graphs are ubiquitous in software engineering:
Package dependencies form directed graphs, as do module imports. The internet is a graph of links between webpages. Model checkers analyze software by exploring the “state space” of all possible configurations.
Microfeatures I'd like to see in more languages
There are roughly three classes of language features: Features that the language is effectively designed around, such that you can't add it after the fact....
Google’s Fully Homomorphic Encryption Compiler — A Primer
Back in May of 2022 I transferred teams at Google to work on Fully Homomorphic Encryption (newsletter announcement). Since then I’ve been working on a variety of projects in the space, includ…
Will I be able to access proprietary platform APIs (e.g. Android / iOS)?
The kind of binary format being considered for WebAssembly can be natively decoded much faster than JavaScript can be parsed (experiments show more than 20× faster).
The future of Clang-based tooling
By Peter Goodman Clang is a marvelous compiler; it’s a compiler’s compiler! But it isn’t a toolsmith’s compiler. As a toolsmith, my ideal compiler would be an open book, allowing me to get to…
Fast Multidimensional Matrix Multiplication on CPU from Scratch
Numpy can multiply two 1024x1024 matrices on a 4-core Intel CPU in ~8ms.This is incredibly fast, considering this boils down to 18 FLOPs / core / cycle, with...
Efficient n-states on x86 systems
The text discusses how to efficiently handle control flow in x86 systems when a flag can have multiple states beyond true and false. It explains how to use condition codes, such as testing for zero and parity, to minimize the number of instructions needed for these tests. Additionally, it touches on the challenges and limitations of using inline assembly for optimization in C programming.
Program tuning as a resource allocation problem
Program tuning involves balancing simplicity and performance while sharing cache resources among various subsystems. Optimizing one function can impact others, making it a global resource allocation problem that requires careful consideration of algorithms and their resource footprints. Better tools and metrics are needed to manage and analyze cache resource consumption effectively.
How web bloat impacts users with slow connections
Web bloat makes many websites difficult to use for people with slow internet connections and devices. Sites like Discourse and Reddit perform poorly on low-end devices, even if they seem fast on high-end ones. Improving web performance for these users is crucial, as many people rely on older, slower devices.
Files are hard
Writing files in a way that ensures their robustness is challenging due to the complexity involved. The paper discusses various issues related to file corruption and data loss, such as crash consistency, filesystem semantics, filesystem correctness, error handling, and error recovery. It highlights the differences in how different filesystems handle errors and points out bugs and inconsistencies found in popular filesystems. The paper also addresses the frequency of disk errors and data corruption, emphasizing the need for caution when writing files and the importance of using libraries or tools to ensure safety. Overall, the document emphasizes the difficulty of reasoning about file-related problems and the need for careful considerations when working with filesystems.
Ringing in a new asynchronous I/O API
The new "io_uring" interface simplifies asynchronous I/O in the Linux kernel by using two ring buffers for submission and completion queues. Applications can set up these buffers with a system call and submit I/O requests through a structured format. This method aims to reduce complaints about AIO by improving efficiency and ease of use.
applicative-mental-models
The text discusses the importance of understanding program performance for effective optimization. It emphasizes that while most optimizations may not be necessary, being aware of critical performance paths is essential. The author provides latency numbers to help programmers grasp the impact of different operations on performance.
Optimizing subroutines in assembly language
Optimizing subroutines in assembly language involves various techniques such as using inline assembly in a C++ compiler, separating code using MMX registers from code using ST registers, and understanding different register sizes and memory operands. It is important to consider the use of instruction prefixes, intrinsic functions for vector operations, and accessing class and structure members efficiently. Additionally, preventing false dependences, aligning loop and subroutine entries, and optimizing instruction sizes can improve performance. However, it is crucial to note that these optimizations are processor-specific and may vary depending on the target platform.
Demystifying programs that create programs, part 1: A disassembler
This blog post starts a series on creating programs that demystify how programs work. The first program is a disassembler that reads bytecode and converts it into assembly language, while a future post will cover creating an assembler. The disassembler uses a table of mnemonics and instruction sizes to print out the corresponding assembly instructions from bytecode.
QBE vs LLVM
QBE and LLVM are both compiler backends, but QBE is a smaller, more accessible project aimed at amateur language designers. While LLVM is feature-rich and complex, QBE focuses on simplicity and efficiency, making it easier to use for quick projects. QBE provides straightforward operations and a cleaner intermediate language, reducing the complexity often found in LLVM.
Recent presentations and papers
Andi Kleen's work focuses on improving Linux performance through various techniques like hardware monitoring and profiling. He has presented on topics such as lock elision, multi-core scalability, and error handling in the Linux kernel. His contributions include discussions on modern CPU performance, tools for Linux development, and enhancements for energy efficiency.
How long does it take to make a context switch?
Context switching times vary significantly across different Intel CPU models, with more expensive CPUs generally performing better. The performance can be greatly affected by cache usage and thread migration between cores, leading to increased costs when tasks are switched. Optimizing the number of threads to match the number of hardware threads can improve CPU efficiency and reduce context switching overhead.
Ghostty Devlog 001
Ghostty is a terminal emulator developed as a side project. In this devlog, the author shares details about the tech stack behind Ghostty, including its cross-platform capabilities and GPU acceleration. The devlog also introduces two features: automatic shell integration injection and auto-italicize fonts. The shell integration feature improves prompt redrawing, working directory reporting, and active process detection, while the auto-italicize fonts feature fixes a bug and adds the ability to skew regular fonts to create fake italics. The devlog concludes by inviting readers to follow the author on social media for updates and future devlogs.
Tiled Matrix Multiplication
Tiled matrix multiplication is an efficient algorithm used on GPUs that reduces memory access by utilizing shared memory. By organizing threads into blocks, each thread can perform calculations more quickly and with fewer memory accesses. This method is important for improving performance in tasks like graphics rendering and machine learning.
Rust Atomics and Locks
This book by Mara Bos explores Rust programming language's concurrency features, including atomics, locks, and memory ordering. Readers will gain a practical understanding of low-level concurrency in Rust, covering topics like mutexes and condition variables. The book provides insights on implementing correct concurrency code and building custom locking and synchronization mechanisms.
Compiler Backend
The QBE compiler backend is designed to be a compact yet high-performance C embeddable backend that prioritizes correctness, simplicity, and user-friendliness. It compiles on various x64 operating systems and boasts features like IEEE floating point support, SSA-based intermediate language, and quick compilation times. While currently limited to x64 platforms, plans include ARM support and further enhancements. The backend has been successfully utilized in various projects, showcasing its adaptability and effectiveness in compiler development.
Vale's Memory Safety Strategy: Generational References and Regions
Vale's memory safety strategy uses generational references to manage memory without relying on traditional methods like garbage collection. Each reference stores a "generation" ID, and before accessing an object, a check ensures the ID matches the object's current generation. This approach allows for efficient memory management while maintaining safety, reducing overhead significantly compared to other methods.
Introduction
Wait-freedom ensures that each thread can progress independently, executing operations in a fixed number of steps without being blocked by others. Lock-freedom allows the system to make overall progress, but individual threads might still get stuck. Obstruction-freedom means a thread can only progress without interference from others, making it a weaker guarantee than lock-freedom.
Cache-Oblivious Algorithms
Cache-oblivious algorithms are designed to use processor caches efficiently without needing to know specific cache details. They work by dividing data into smaller parts, allowing more computations to happen in cache and reducing memory access. This leads to better performance, especially in parallel algorithms, by minimizing shared memory bottlenecks.
A Memory Allocator
A memory allocator is software that manages dynamic memory allocation in programs, providing functions like malloc(), free(), and realloc(). This particular allocator aims to minimize memory wastage and improve efficiency, and it is widely used in various systems, including Linux. It employs techniques like coalescing freed chunks and supports memory mapping to enhance performance and reduce fragmentation.
1024cores
Dmitry Vyukov shares information on synchronization algorithms, multicore design patterns, and high-performance computing on his website, 1024cores.net. He focuses on shared-memory systems and does not cover topics like clusters or GPUs. New content is added regularly, and readers can subscribe for updates.
Implementing interactive languages
Implementing an interactive language requires considering both compile-time and run-time performance. Traditional switch-based bytecode interpreters are easy to implement but have lower run-time performance compared to optimizing compilers. A sweet spot in performance can be found by aiming for combined compile-time and run-time performance within a certain range. Various options for implementing fast interpreters, existing compilers like LLVM and Cranelift, custom compilers, and using WebAssembly as a backend are discussed. The idea of having two backends for a language to support quick startup and aggressive optimization is also explored. There are still many unknowns and further research is needed to determine the feasibility and performance of different approaches.
Pointers Are Complicated, or: What's in a Byte?
The document explains the complexities of pointers in low-level programming languages like C++ and Rust, debunking the misconception that pointers are simple integers. It delves into examples showing how assumptions about pointers can lead to undefined behavior and how pointer arithmetic can be tricky. The text proposes a model where a pointer is a pair of an allocation ID and an offset, rather than just an integer. Additionally, it discusses the challenges of representing bytes in memory, especially when dealing with uninitialized memory and the need for a more nuanced byte representation to ensure program correctness.
Three Architectures for a Responsive IDE
The text discusses three architectures for a responsive IDE: indexing on a per-file basis, using a FQN index for completion, and a query-based compiler approach. Each approach has its own challenges and benefits, such as handling macro expansions and managing dependencies efficiently to ensure fast performance.
How a Zig IDE Could Work Feb 10, 2023
The author discusses how to build an Integrated Development Environment (IDE) for the Zig programming language, which has unique features like a simple syntax but also complex compile-time evaluation. The IDE needs to handle incomplete code and provide immediate feedback while managing rapid code changes. The post explores various strategies for efficiently processing code, such as using abstract interpretation and optimizing compilation to focus only on necessary parts of the codebase.
Properly Testing Concurrent Data Structures Jul 5, 2024
The article discusses how to effectively test concurrent data structures by using managed threads that can be paused and resumed. It explains the importance of controlling thread execution to avoid issues like race conditions while executing random operations. The author emphasizes the need for proper synchronization mechanisms to ensure that only one thread is active at a time during tests.
Parse, don’t validate
The text discusses the importance of parsing over validating in Haskell to prevent errors and enhance code reliability by using strong argument types. Parsing upfront helps maintain consistency and avoids potential issues with partial input processing, demonstrating the benefits of type-driven design in Haskell programming. The text also touches on the subjective nature of programming languages, highlighting differing perceptions of Haskell and the challenges faced by learners in navigating diverse opinions.
Too Fast, Too Megamorphic: what influences method call performance in Java?
The performance of method calls in Java can be improved through techniques like inlining and using inline caches. Monomorphic calls, where only one method can be invoked, are the fastest, while bimorphic and megamorphic calls are slower due to increased lookup costs. The study highlights that simply adding the "final" keyword or overriding methods does not significantly enhance performance.
The Black Magic of (Java) Method Dispatch
The content shows code execution percentages for different operations within a program. It includes instructions for handling different coders, with comparisons and jumps based on coder values. The code includes sections like the main entry point, epilogue, handling other coders, and specific coder cases like Coder1 and Coder2.
Why null sucks, even if it's checked
The article discusses the problems with using null in programming languages like Kotlin and C#, highlighting that null can lead to confusion and errors. It argues that null is not an extensible solution for representing absence of value and suggests using sum types or optional types instead. The author believes that languages should focus on improving optional types rather than trying to make null safer.
Resources for Building Programming Languages
The article shares resources for learning how to create programming languages, focusing on Rust and C. It highlights the book "Crafting Interpreters," which provides practical insights into building interpreters using different programming approaches. The author also discusses their personal experience building a language and the tools they've found helpful, like LLVM and Cranelift.
Little 'Big Ideas' in Programming Language Design
Colin Davis discusses "little big ideas" in programming language design, focusing on the balance between innovative features and conventional choices. He highlights Mojo and Go as examples, noting how Mojo combines modern improvements with familiar concepts, while Go prioritizes simplicity and a strong ecosystem. Davis suggests that small design decisions, like memory management and parameter passing, can greatly enhance a language's usability and performance.
Computer Networking: A Top-Down Approach
Jim Kurose and Keith Ross are prominent computer science professors with extensive experience in networking and related fields. They have received multiple awards for their teaching and research, and both have held leadership roles in academic and professional organizations. Their work focuses on topics like network protocols, security, and multimedia communication.
Using Uninitialized Memory for Fun and Profit Posted on Friday, March 14, 2008.
A clever trick involves using uninitialized memory to improve performance in certain programming situations by representing sparse sets efficiently with two arrays that point at each other. This technique allows for fast constant-time operations for adding, checking, and clearing elements in the set, making it a valuable tool for optimizing algorithms and data structures. The sparse set representation is especially useful for scenarios where speed is critical, such as in compiler optimizations and graph traversal algorithms.
Zip Files All The Way Down
The text discusses creating self-reproducing programs and files like zip files that can decompress to themselves. It explores using Lempel-Ziv compression for self-reproduction and the challenges of translating these concepts into real opcode encodings like DEFLATE used in gzip and zip files. The ultimate goal is to create a zip file that contains a larger copy of itself recursively, creating a chain of expanding zip files.
Minimal Boolean Formulas
The post discusses how to compute the minimum number of AND and OR operators needed for Boolean functions with five variables. It describes the author's program that efficiently calculates this minimum for various functions while also improving algorithms for speed. The findings contribute to understanding the complexity of Boolean functions and their representations.
Hacking the OS X Kernel for Fun and Profiles Posted on Tuesday, August 13, 2013.
The article discusses a bug in the OS X kernel related to how profiling signals are delivered in multithreaded processes. It explains that the kernel incorrectly sends the SIGPROF signal to the entire process instead of the specific running thread. The author outlines a fix involving a small edit to the kernel code to ensure the signal is sent to the correct thread.
How To Build a User-Level CPU Profiler Posted on Thursday, August 8, 2013.
The text discusses how the pprof tool simplifies CPU profiling for C++ and Go programs by utilizing hardware timers and the operating system. Profiling information is gathered through hardware interrupts, providing insights into a program's performance and resource usage. By moving profiling logic to user-level timers, programs can customize and enhance profiling capabilities without kernel changes.
An Encoded Tree Traversal
The text discusses different ways to traverse binary trees and how these methods can be generalized to k-ary trees. It highlights a new ordering for traversing k-ary trees that results in a regular numbering pattern, which is not present in the traditional methods. The author seeks references or examples of this k-ary-coded traversal order, which he has not yet found.
Our Software Dependency Problem
The text discusses the risks and benefits of using software dependencies in programming. It emphasizes the importance of understanding, managing, and monitoring dependencies to prevent potential issues like bugs and security vulnerabilities. The article highlights the need for developers to establish best practices for effectively utilizing dependencies in their projects.
Running the “Reflections on Trusting Trust” Compiler Posted on Wednesday, October 25, 2023.
The text discusses how to modify a C compiler to insert a backdoor into a program without leaving traces in the source code. It explains that the backdoor can be detected because the compiler's size increases each time it compiles itself. Finally, it highlights the importance of using trusted compilers to prevent hidden backdoors in modern software development.
Improving the Font Pipeline
To improve the font pipeline, consider how to efficiently choose and render glyphs for different languages, including handling ligatures and memory constraints. You may need to create texture atlases for various glyphs while ensuring new translations are incorporated. Finally, optimize rendering to avoid blurriness and ensure smooth performance across different character sets.
Easy Scalable Text Rendering on the GPU
This text explains a fast and memory-efficient technique for rendering text on the GPU without using traditional methods like signed distance fields. It uses triangles to fill in pixels inside the glyph and supports subpixel anti-aliasing for crisp text on LCD screens. The technique is resolution-independent, simple to implement, and can be extended to enhance rendering quality.
Adventures in Text Rendering: Kerning and Glyph Atlases
Text rendering involves converting vector glyphs to bitmaps, positioning them on screen, and optimizing performance by using glyph atlases. Glyph atlases store rasterized glyphs efficiently, allowing for sub-pixel alignment and improved rendering quality. This approach balances performance and quality in text rendering for different types of fonts.
Exploring the Power of Negative Space Programming
Negative space programming helps improve code by defining what it should not do, making it more robust and clear. By using constraints and assertions, developers can catch errors early and enhance security. This approach also promotes simplicity, making the code easier to maintain and understand.
CompilerTalkFinal
The content discusses various compilers and their features, including Clang, GCC, V8, CakeML, Chez Scheme, and more. It also touches on the history of interpreters and compilers, with examples like ENIAC and the first compiler developed by Grace Hopper. Different approaches to compilation and interpretation are highlighted, showcasing the evolution of compiler technology.
Graydon Hoare: 21 compilers and 3 orders of magnitude in 60 minutes
Graydon Hoare's talk explains different approaches to building compilers, from traditional giants to more efficient variants. He highlights the importance of using compiler-friendly languages and theory-driven meta-languages. The presentation covers key concepts like sophisticated partial evaluation and implementing compilers directly by hand.
p75-hoare
The author recounts experiences in designing a computer programming language and issues a warning about language complexity. Despite challenges, a subset of the language was successfully implemented. The author emphasizes the importance of simplicity and reliability in programming languages for critical applications.
Updating the Go Memory Model
The Go memory model needs updates to clarify how synchronization works and to endorse race detectors for safer concurrency. It suggests adding typed atomic operations and possibly unsynchronized atomics to improve program correctness and performance. The goal is to ensure that Go programs behave consistently and avoid data races, making them easier to debug.
Programming Language Memory Models (Memory Models, Part 2) Posted on Tuesday, July 6, 2021. PDF
Modern programming languages use atomic variables and operations to help synchronize threads and prevent data races. This ensures that programs run correctly by allowing proper communication between threads without inconsistent memory access. All major languages, like C++, Java, and Rust, support sequentially consistent atomics to simplify the development of multithreaded programs.
Hardware Memory Models (Memory Models, Part 1) Posted on Tuesday, June 29, 2021. PDF
This text discusses hardware memory models, focusing on how different processors handle memory operations and maintain order. It explains the concept of sequential consistency, where operations are executed in a predictable order, and contrasts it with more relaxed models like those used in ARM and POWER architectures. The author highlights the importance of synchronization to avoid data races in concurrent programming.
Baby Steps to a C Compiler
Writing a simple compiler can help you understand how computers work. Start with a minimal project that compiles a small subset of a language, and then gradually add more features. This approach makes learning about compilers and programming enjoyable and rewarding.
Kernel Programming Guide
Essential information for programming in the OS X kernel. Includes a high-level overview.
Tiny Tapeout
Tiny Tapeout is a project that helps people easily and affordably create their own chip designs. It offers resources for beginners and advanced users, along with a special price for submissions. Join the community to learn and share your designs before the deadline on September 6th.
Why Pascal is Not My Favorite Programming Language
Pascal is not recommended for serious programming due to limitations in its standard form. The language's strict typing and lack of features like separate compilation make it challenging for complex projects. Pascal is better suited for educational purposes rather than practical programming tasks.
What Color is Your Function?
Functions in a programming language can be either red or blue, affecting how they are called and used. Red functions are asynchronous and typically more complex to work with than blue functions. The choice between red and blue functions can impact code organization and maintainability.
What is an Invariant? Oct 6, 2023
Invariants are properties that hold true during the evolution of a system, helping to ensure correct behavior in programming. They can simplify reasoning about code, whether it’s for small algorithms or larger systems. By clearly defining invariants, programmers can create robust code and manage complex systems effectively.
Crafting an Interpreter in Zig - part 1
The author is learning Zig by implementing an interpreter for the Lox programming language, inspired by the book "Crafting Interpreters." They are documenting their journey, focusing on interesting aspects of Zig and how it differs from C. So far, they have enjoyed the process, particularly the simplicity and power of Zig's generic programming.
What Every Computer Scientist Should Know About Floating-Point Arithmetic
The text discusses the challenges and considerations of floating-point arithmetic in computer science. It emphasizes the importance of rounding in floating-point calculations and the implications of different precision levels. Additionally, it highlights the need for careful implementation to ensure correctness and accuracy in programs that rely on floating-point arithmetic.
The Development of the C Language*
The paper discusses the development and influences of the C programming language, highlighting its creation at Bell Labs and transition from the B language. C's simplicity, efficiency, and widespread adoption across various platforms and architectures are emphasized, showcasing its enduring stability and usefulness in software development. Despite its quirks and historical origin, C has proven to be a powerful and versatile language for programmers worldwide.
A Note About Zig Books for the Zig Community
The author discusses the idea of writing a Zig book and shares personal plans for self-publishing their own book. They weigh the pros and cons of working with a publisher versus self-publishing, emphasizing the importance of considering creative freedom and revenue sharing. The author encourages those interested in writing a Zig book to carefully evaluate their options, noting that the Zig community values learning materials and support.
Your Starting Point!
The text discusses the concepts of three-dimensional objects and how they are represented in two dimensions for computer graphics. It explains the process of projecting 3D points onto a canvas to create images. The importance of geometry and mathematics in computer graphics, particularly in defining objects and creating images, is emphasized.
Zig Interfaces for the Uninitiated, an update
The post discusses a new idiom for runtime polymorphism in Zig, focusing on using fat pointers instead of @fieldParentPtr. It provides a step-by-step guide on creating a formal Iterator interface and implementing it with an example range iterator. The drawbacks of this pattern include potential performance issues and the requirement for the original implementor to remain alive for the interface to function correctly.
Zig Interfaces for the Uninitiated
The text discusses how to create and implement generic iterators in Zig using interfaces like `Iterator` and `Range`.
It demonstrates how to use these iterators to iterate over ranges of values and provides examples of ascending, descending, and skipping ranges.
Additionally, it introduces a function `fold` to apply a function to successive elements in an iterator, showcasing Zig's runtime polymorphism for data structures.
Exploring Compile-Time Interfaces in Zig
Zig is a programming language with active community support and a focus on efficient, reusable software development. Interfaces in Zig define a blueprint for classes to implement specific methods, promoting code abstraction and flexibility. Compile-time interfaces in Zig optimize code structure by resolving methods during compilation for efficient program execution.
Aro - a C compiler
Aro is a C compiler created as an alternative to Zig's compiler. It includes the aro module for the compiler and a language-agnostic aro_backend module for translating code into machine code. Aro uses self-hosted backends from the Zig compiler for optimization.
Database Systems
This course at CMU covers database management systems, including data models, query languages, storage architectures, and more. It uses case studies to show real-world applications and is suitable for students with basic systems programming skills. The course also thanks companies for their support in equipment donations and course development.
Discovering and exploring mmap using Go
Memory-mapped files allow programs to access disk data larger than available memory. By using mmap in Go, you can map a file directly into memory for easier manipulation. Virtual memory techniques, like mmap, can help solve memory limitations in handling large files efficiently.
But how, exactly, databases use mmap?
Databases use memory-mapped files like mmap to handle data on disk larger than available memory. Examples include SQLite, LevelDB, Lucene, LMDB, and MongoDB. By understanding how mmap is used, we can grasp how databases efficiently read and write data from disk.
reHow memory mapped files, filesystems and cloud storage works
Kelly discusses the challenges of memory-mapped files and cloud storage in response to a comment about space reservation in Voron. Cloud providers may allocate more space than needed, leading to unexpected charges and unreliable data handling. Testing reveals issues with sparse files and memory mapping in cloud scenarios, highlighting the importance of understanding storage limitations.
Implementing a file pager in Zig
Implementing a file pager in Zig involves delaying disk writes until a threshold is reached. Two eviction strategies include least recently used and least frequently used models. Prioritizing pages based on usage can help optimize performance.
Criticizing Hare language approach for generic data structures
The blog criticizes the Hare language approach for not providing generic data structures like hash maps in its standard library. It highlights the complexity and importance of hash tables in various programming languages and emphasizes the need for efficient data structures in modern programming ecosystems. The author disagrees with Hare's approach and stresses the significance of hash tables in software development.
spikedoanz/from-bits-to-intelligence: machine learninig stack in under 100,000 lines of code
The text discusses building a machine learning stack in under 100,000 lines of code with hardware, software, tensors, and machine learning components. It outlines the required components like a CPU, GPU, storage, C compiler, Python runtime, operating system, and more. The goal is to simplify the machine learning stack while providing detailed steps for implementation in different programming languages.
One year of C
The author reflects on their year of writing C code, finding it enjoyable and productive. They emphasize the importance of choosing the right language for each problem and share insights on the benefits of using C over C++ in certain scenarios. Additionally, they discuss the advantages of C99 improvements and the simplified nature of writing C code compared to C++.
Heap Memory and Allocators
The text discusses different types of memory allocators in Zig programming language.
It explains how memory allocation and deallocation work using alloc and free functions.
Various allocator types like GeneralPurposeAllocator and FixedBufferAllocator are highlighted for managing memory efficiently.
Pointers
—————SOURCES————————————————————————
Percolation – Béla Bollobás and Oliver Riordan
Cambridge University Press, New York, 2006.
Sixty Years of Percolation – Hugo Duminil-Copin
https://www.ihes.fr/~duminil/publi/2018ICM.pdf
Percolation – Geoffrey Grimmett
volume 321 of Grundlehren der Mathematischen Wissenschaften [Fundamental Principles of Mathematical Sciences]. Springer-Verlag, Berlin, second edition, 1999.
—————NOTES—————————————————————————
Note at 10:42 – The uniqueness of the infinite cluster is known for the d-dimenional lattice since the works of Aizenman, Kesten and Newman - [Uniqueness of the infinite cluster and continuity of connectivity functions for short and long range percolation (1987)] and Burton and Keane - [Density and uniqueness in percolation (1989)]. It does not hold in general: when the graph in question is a regular tree for example, there are always infinitely many clusters during the supercritical phase.
The two last results shown here are only known for site percolation (in which vertices are open or closed instead of edges) in the triangular lattice, where a scaling limit for the boundaries of critical clusters was proved to exist (more on that in the third note). It is believed that these results are universal, that is, valid in great generality for planar percolation processes near criticality.
The third result is from an appendix by Gábor Pete in the paper [Scaling limits for the threshold window: When does a monotone Boolean function flip its outcome? (2017)] by Ahlberg and Steif. Consider an n by n box, and the event where there exists a left-right crossing of said box. Recall the uniform coupling from the video: intuitively, the result is saying that the point at which this crossing emerges in the uniform coupling is with high probability inside an interval of size n^{-3/4} around 1/2.
The fourth result is saying that the average size of the cluster of the origin (or any other given point) goes to infinity as we let p approach the critical parameter like a specific power of the distance between p and p_c. This power is called a critical exponent. The existence of these exponents was proved by Smirnov and Werner in the paper [Critical exponents for two-dimensional percolation (2001)].
Note at 10:52 – Hugo Duminil-Copin has several major contributions to the study of processes arising in statistical physics, including Bernoulli percolation. Among his works on Ising and Ising-like processes we can cite [Random Currents and Continuity of Ising Model’s Spontaneous Magnetization (2015)] with Aizenman and Sidoravicius and [Sharp phase transition for the random-cluster and Potts models via decision trees (2019)] with Raoufi and Tassion.
Note at 12:38 – In the triangular lattice site percolation, Stanislav Smirnov proved the conformal invariance of crossing probabilities at criticality (see https://www.unige.ch/~smirnov/papers/icmp-final.pdf for an overview), which led to the proof of the existence of scaling limits of exploration curves as Schramm–Loewner evolution processes. See [Critical percolation in the plane (2009)] by Smirnov. This provided a deep understanding of the critical phase in the triangular lattice site percolation, which to this day is not extended to the square lattice.
Note at 17:52 – It is not at all obvious that the probability of being connected to infinity is continuous above criticality. This result can be proved in the d-dimenional hypercubic lattices using the uniqueness of the infinite cluster, and more generally it was proved for transitive graphs (intuitively, graphs in which all vertices look the same) by Häggström, Peres and Schonmann in [Percolation on transitive graphs as a coalescent process: Relentless merging followed by simultaneous uniqueness (1999)].
—————SECTIONS———————————————————————
0:00 Introduction
1:37 Definition – Bernoulli Percolation
5:23 Definition – Uniform Coupling
7:56 Exploration – High-Resolution Square Grid
9:40 Exploration – Questions and Kesten's Theorem
10:58 Exploration – Ising Model
11:54 Exploration – Critical Percolation
12:50 Exploration – Three-Dimensional Cubic Lattice and Beyond
14:13 Proof – Theorem Statement
15:14 Proof – Simplifications
16:29 Proof – Definition of Critical Parameter
18:41 Proof – Critical Parameter is Greater Than Zero
20:44 Proof – Duality Definition
21:56 Proof – Critical Parameter is Less Than One
25:16 Proof – Summary and Idea for Kesten's Theorem
26:11 Conclusion
—————CREDITS————————————————————————
Caio Alves – writing, 3D animation
Aranka Hrušková – writing, clarinet
Vilas Winstein – writing, 2D animation, editing, voice-over
Special thanks to Anisah Awad, Gábor Pete, Jyotsna Sreenivasan, Angie Zavala
This video is an entry in the second Summer of Mathematics Exposition (#SoME2)
The photographs used in this video are licensed under the Creative Commons Attribution-ShareAlike license:
https://creativecommons.org/licenses/by-sa/4.0/deed.en
Uploader: Spectral Collective
Duration: 1612s
Views: 455517
Emulator 101
A detailed, step by step guide to writing an emulator
Data Compression Explained
Data compression involves modeling and coding to reduce the size of data files. Modern compressors typically use arithmetic coding for efficient compression. Algorithms like Huffman coding and run-length encoding are commonly used to achieve better compression results.
Twitter's Recommendation Algorithm
Twitter uses a recommendation algorithm to select the top tweets for users' timelines. The algorithm is based on core models and features that extract information from tweet, user, and engagement data. The recommendation pipeline consists of three main stages: candidate sourcing, ranking, and applying heuristics and filters. Twitter uses both in-network and out-of-network sources to find relevant tweets, and employs embedding spaces to determine content similarity. The final step involves blending tweets with other non-tweet content before sending them to users' devices. The goal of Twitter's open source endeavor is to provide transparency to users about how the recommendation system works.
Programming languages resources
This page is a collection of the author's favorite resources for people getting started writing programming languages. The resources cover various aspects such as compilers, runtimes, runtime optimization, pointer tagging, JIT compilers, assembler libraries, and interesting tools. The author also mentions topics they want to write about in the future and papers they want to read. The page is meant to be a helpful reference for those interested in programming language implementation.
3D Math Primer for Graphics and Game Development
The book "3D Math Primer for Graphics and Game Development" is available to read for free on the gamemath.com website. It includes information about GDC talks, FAQs, and resources for the first edition of the book. The first edition, published in 2002, is described as high tech, but the author recommends reading the second edition instead, which is also available for free.
Welcome to OpenGL
This text is about learning modern OpenGL through an online book that covers basic, intermediate, and advanced knowledge with clear examples and practical concepts. The content is freely available online and in print, with the aim of providing a complete and easy-to-understand platform for graphics programming enthusiasts. Readers will learn core graphics aspects, useful techniques, and even create a small game based on the obtained OpenGL knowledge.
WebGPU Fundamentals
The text provides a collection of articles to help beginners learn the basics of WebGPU, covering topics like fundamentals, 3D math, lighting techniques, and compute shaders. It also includes information on optional features, data memory layout, transparency, performance, and resources for further learning. Readers can explore various aspects of WebGPU, including how it works, 2D and 3D techniques, and essential concepts like uniforms, textures, and storage buffers.
An opinionated beginner’s guide to Haskell in mid-2019
This guide is for beginners in Haskell or those transitioning from similar languages, offering advice on learning resources and tools. It emphasizes the importance of writing Haskell code, getting help online, choosing popular platforms, and sticking to the default Prelude. The guide also touches on application architecture, using records, debugging techniques, and the experimental nature of Haskell as both a research and industrial language.
Are tagged unions overrated?
The author discusses the limitations of tagged unions and pattern matching in language development, suggesting that they are overrated for implementing language ASTs and IRs. Despite the benefits of tagged unions, the complexity they add may not always justify their use, especially in cases where simpler alternatives like class hierarchies can offer similar functionality. The post also highlights the potential for enhancing pattern-matching capabilities in mainstream languages to improve code readability and maintainability.
C++ Core Guidelines
These guidelines aim to simplify and improve the safety of C++ code by recommending specific extensions and best practices. They focus on static type safety, resource management, and reducing the likelihood of errors or accidents. By following these guidelines, programmers can write more correct, safer code without sacrificing performance.
What every systems programmer should know about concurrency
The document delves into the complexities of concurrency for systems programmers, explaining the challenges of running multithreaded programs where code is optimized and executed in unexpected sequences. It covers fundamental concepts like atomicity, enforcing order in multithreaded programs, and memory orderings. The text emphasizes the importance of understanding how hardware, compilers, programming languages, and applications interact to create a sense of order in multithreaded programs. Key topics include atomic operations, read-modify-write operations, compare-and-swap mechanisms, and memory barriers in weakly-ordered hardware architectures.
compiler_construction
Building a compiler can be straightforward by breaking the development into small steps and using Scheme as the implementation language. The tutorial focuses on translating a subset of Scheme to assembly code, with a step-by-step approach to achieve a fully working compiler. Testing and refining the compiler incrementally leads to a powerful tool capable of compiling an interactive evaluator.
How do we tell truths that might hurt?
The document discusses the challenges of telling unpleasant truths and the conflict that arises when sharing these truths in the field of Computing Science. The author argues that remaining silent about these truths compromises the intellectual integrity of the field. The document also lists a number of truths related to programming languages and the use of language in computing systems. The author questions whether the field should continue to ignore these truths and urges for a change in attitude.
The next fifty years
The text discusses the future of computing science over the next fifty years, emphasizing the importance of simplicity and elegance in design to prevent complexity. It highlights the close connection between program design and proof design, suggesting that advancements in program design can impact general mathematics. The author encourages embracing the opportunity to simplify processes and design systems that rely on formal mathematics.
http client in the standard library · Issue #2007 · ziglang/zig
The issue #2007 discusses the implementation of an HTTP client in Zig's standard library. Contributors debate the necessity and scope of including an HTTP client, considering factors like complexity and resource allocation. Ultimately, the HTTP client implementation was completed and closed as part of milestone 0.12.0.
Introduction to Compilers and Language Design
A compiler translates high-level code to lower-level code, and building one is a common project in computer science education. This book provides a beginner-friendly guide to building a compiler for a C-like language, suitable for undergraduates with programming experience. The author offers free online access to the textbook and related code resources, with options to purchase a physical copy.
Bare Metal Zig
The text discusses compiling a freestanding Zig binary to run on "bare metal" without relying on an operating system. It shows how to create a simple freestanding binary, make it multiboot compliant, and add custom console functionality for output. The process involves targeting specific architectures, handling linker warnings, and ultimately creating a bootable "kernel" to run on virtual machines like QEMU.
Comparing SIMD on x86-64 and arm64
The text compares SIMD implementations using SSE on x86-64 and Neon on arm64 processors, including emulating SSE on arm64 with Neon. It explores vectorized code performance using intrinsics, auto-vectorization, and ISPC, highlighting the efficiency of SSE and Neon implementations. The study shows how optimizing for SIMD instructions significantly boosts performance over scalar implementations in ray-box intersection tests.
Compiler Optimizations Are Hard Because They Forget
Compiler optimizations involve breaking down complex changes into smaller, more manageable steps to improve code efficiency. However, as more optimizations are added, the potential for errors and missed opportunities increases, making it challenging to maintain optimal performance. Compilers struggle with balancing aggressive optimizations while preserving correct program behavior, highlighting the complexity and difficulties inherent in optimizing compilers.
C Isn't A Programming Language Anymore
C is no longer just a programming language but a vital protocol for all languages. Parsing C headers is a complex task best left to C compilers. Maintaining ABI compatibility in C can be challenging and may require versioning schemes.
Writing a C Compiler, Part 1
This text is about creating a C compiler in multiple stages, starting with lexing, parsing, and code generation. The process involves breaking down the source code, building an abstract syntax tree, and generating x86 assembly code. The compiler will handle simple programs with a single main function and a return statement.
GitHub - DoctorWkt/acwj: A Compiler Writing Journey
This GitHub repository documents the author's journey to create a self-compiling compiler for a subset of the C language. The author shares steps taken and explanations to help others follow along practically. The author credits Nils M Holm's SubC compiler for inspiration and differentiates their code with separate licensing.
A new JIT engine for PHP-8.4/9
A new JIT engine for PHP is being developed, improving performance and simplifying development. The engine will be included in the next major PHP version, potentially PHP 9.0. The new JIT engine generates a single Intermediate Representation (IR), eliminating the need to support assembler code for different CPUs.
Unknown
Hardware prefetching in multicore processors can be too aggressive, wasting resources and impacting performance for co-running threads. Combining hardware and software prefetching can optimize performance by efficiently handling irregular memory accesses. A method described in Paper II offers a low-overhead framework for accurate software prefetching in applications with irregular access patterns.
Introduction 2016 NUMA Deep Dive Series
The 2016 NUMA Deep Dive Series by staroceans.org explores various aspects of computer architecture, focusing on NUMA systems and their optimization for performance. The series covers topics such as system architecture, cache coherency, memory optimization, and VMkernel constructs to help readers understand and improve their host design and management. The series aims to provide valuable insights for configuring and deploying dual socket systems using Intel Xeon processors, with a focus on enhancing overall platform performance.
von Neumann architecture - Wikipedia
The von Neumann architecture is a computer design with a processing unit, control unit, memory, and input/output mechanisms. It allows for instructions and data operations to be stored in memory, advancing computer technology from fixed-function machines like the ENIAC. This architecture was influenced by the work of Alan Turing and John von Neumann and has been widely used in the development of modern computers.
Compiling tree transforms to operate on packed representations
The article explains how tree traversals in programming can be optimized by compiling them to work on serialized tree structures without using pointers. This approach can make programs run significantly faster on current x86 architectures. The authors developed a prototype compiler for a functional language that generates efficient code for traversing trees using packed data representations.
Pipelines Support Vectorized, Point-Free, and Imperative Style
The text discusses how pipelines in the shell language support vectorized operations on collections and point-free style, where no data is explicitly mentioned. It also demonstrates how imperative code can be incorporated within pipelines for tasks like generating HTML tables. The unique features of pipelines include their ability to handle vectorized code, point-free composition, and integration of imperative instructions.
Entering text in the terminal is complicated
Entering text in the terminal can be challenging due to inconsistencies in how different programs handle text input. Some programs support basic features like arrow keys and history navigation, while others have custom input systems with advanced functionalities. Understanding the input mode of a program can help users navigate text editing more effectively in the terminal.
What happens when you start a process on Linux?
The process of starting a new program on Linux involves using the fork and exec system calls. Fork creates a clone of the current process, while exec replaces that clone with the new program to be executed. The new process inherits most attributes from its parent, with memory being shared through copy-on-write to optimize performance.
Debug your programs like they're closed source!
The author discusses debugging programs without looking at the source code by using system calls like open, execve, and write. System calls allow you to understand and monitor a program's behavior without needing access to its source code. By learning and utilizing system calls, you gain debugging superpowers that are platform-independent and useful for closed-source programs.
How I got better at debugging
Julia Evans shares her journey of improving her debugging skills through logical thinking, confidence, expanding knowledge, communication, and using tools like strace and tcpdump. By being systematic, confident, knowledgeable, and open to collaboration, she transformed debugging from a challenging task to an exciting learning opportunity. Her story emphasizes the importance of persistence, curiosity, and practical problem-solving in mastering the art of debugging.
Media Page Under Construction
Handmade Cities' media page is under construction, with some recordings missing. The videos from Handmade Boston 2023 have poor audio quality due to using a third-party A/V company. Freya's Masterclass footage was lost, and an abridged version will be shown at Dutch Game Day.
Infographics: Operation Costs in CPU Clock Cycles
The text discusses the operation costs in CPU clock cycles for different types of operations, including simple operations, floating-point operations, and vector operations. It highlights that memory involvement can significantly impact operation costs, with some operations taking as little as 1 CPU cycle. Different CPU architectures and types of operations can result in varying costs, with some operations requiring specialized CPU support to work efficiently.
Handles are the better pointers
The text discusses using 'index-handles' instead of raw or smart pointers for memory management in C and C++. It suggests centralizing memory management into systems, grouping items into arrays, and converting handles to pointers only when necessary. By following specific rules, such as not storing pointers and using handle-to-pointer conversion, memory safety and efficient memory usage can be maintained.
You're Not Sick of Programming
Many people feel tired of programming and dream of quitting for a more fulfilling career, like farming or traveling. However, the real issue might be frustration with office politics, lack of product vision, and burnout rather than a true dislike of programming. Taking a break or addressing these underlying problems could help rediscover the creative potential of programming.
Zig Bare Metal Programming on STM32F103 — Booting up
The text explains how to program the STM32F103 microcontroller using the Zig programming language. It covers topics such as memory layout, linker scripts, and compiling code for embedded systems. By following the provided instructions, readers can successfully compile and run their first embedded program on the microcontroller.
OWASP Top Ten
The OWASP Top 10 is a guide for developers to understand critical security risks in web applications. Companies are encouraged to follow this document to improve the security of their web applications. The 2021 update includes new categories and ranking changes based on testing data and industry feedback.
Introduction
The OWASP Cheat Sheet Series offers valuable security information on application security topics. Created by experts, these concise cheat sheets aim to provide easy-to-read security guidance. You can download the cheat sheets from this site and stay updated through the ATOM feed.
The Copenhagen Book
The Copenhagen Book is a free and open-source guide for implementing auth in web applications. It is community-maintained and can be used alongside the OWASP Cheat Sheet Series. Suggestions or concerns can be addressed by opening a new issue.
Undefined Behavior deserves a better reputation
Undefined Behavior is often viewed negatively, but it can be a valuable tool for language designers. It allows programmers to convey insights to the compiler for optimizations. Responsible use of Undefined Behavior can enhance language design and code performance.
KHM+15
The text discusses a formal C memory model that supports integer-pointer casts, essential for low-level C programming. It proposes a quasi-concrete memory model that allows standard compiler optimizations while fully supporting integer-pointer casts. This model helps verify programs and optimizations that are challenging to validate with integer-pointer casts.
Learning LLVM (Part-1) - Writing a simple LLVM pass
This text introduces learning about LLVM and writing LLVM passes, which are used for transforming or analyzing a program's intermediate representation. LLVM offers a versatile compiler infrastructure with modules like the frontend, middle-end, and backend for optimizing and generating machine-specific code. By understanding LLVM concepts and pass managers, developers can create efficient passes for tasks like performance optimization and code analysis.
Some Were Meant for C
The document "Some Were Meant for C" explores the enduring significance of the C programming language, highlighting its dual role as both an application and systems programming language. It challenges common assumptions about C, emphasizing its unique communicative design that differs from managed languages. The document argues that C's explicit representations and memory access foster effective system-building and communication, making it a preferred choice for certain technical challenges. Additionally, it critiques the prevailing discourse that demonizes C, advocating for a nuanced understanding of its role in the programming landscape.
Xv6, a simple Unix-like teaching operating system
Xv6 is a teaching operating system developed by MIT for their operating systems course. It is based on Unix V6, written in ANSI C, and runs on Intel x86 machines. The xv6 source code is available on GitHub and is used in lectures to teach operating system concepts.
C Is Not a Low-level Language
C is often considered a low-level language, but this article argues that it is not. The author explains that vulnerabilities like Spectre and Meltdown occurred because processor architects were trying to build fast processors that exposed the same abstract machine as a PDP-11, which C programmers believe is close to the underlying hardware. However, the reality is that C code runs on a complex compiler that performs intricate transformations to achieve the desired performance. The article also discusses how C's memory model and optimizations make it difficult to understand and can lead to undefined behavior. The author suggests that instead of trying to make C code fast, it may be time to explore programming models on processors designed for speed.
Should you learn C to "learn how the computer works"?
The author discusses whether learning C is necessary to understand how computers work, ultimately concluding that C is not a direct representation of computer operations. Learning C can still be beneficial for understanding computing concepts and history, but it operates within a virtual machine and abstracts certain hardware details. By learning C, you can gain insight into the relationship between programming languages, hardware, and the historical development of computing.
A Guide to Undefined Behavior in C and C++, Part 1
The text explains that undefined behavior in C and C++ can lead to unpredictable program outcomes. Compilers may optimize code by exploiting undefined behavior, potentially causing programs to misbehave. It is important for programmers to understand how undefined behavior can impact program execution.
When Network is Faster than Cache
Firefox introduced a feature called RCWN to improve web performance by racing cached requests against the network. In some cases, the network can be faster than fetching data from the cache due to various factors like browser bugs and resource prioritization. Factors like device hardware and the total number of assets served from the cache impact cache retrieval performance significantly.
John Carmack on Functional Programming in C++
Functional programming in C++ can help in writing better software by making code easier to reason about and eliminating thread race conditions. Pure functions, which only rely on input parameters and produce consistent outputs, offer benefits such as thread safety and easier testing. Refactoring towards purity can improve code quality, even if full purity is not achieved, by disentangling computation from the environment it operates in.
Zig-style generics are not well-suited for most languages
Zig-style generics, like those in C++, may not work well for all languages due to limitations in compiler support and type inference. Armchair suggestions about adopting Zig-style generics in other languages may overlook these challenges. The flexibility and metaprogramming capabilities in Zig may not easily translate to other statically-typed languages.
WebGL2 vs WebGL1
WebGL is a 3D API that works as a rasterization engine, requiring users to provide code for rendering points, lines, and triangles. Users must create vertex and fragment shaders to control how WebGL processes and displays graphics. The WebGL API simplifies rendering by executing user-created functions to draw basic shapes like triangles.
WebGL How It Works
The text explains how WebGL processes vertices to create triangles and render them with pixels using shaders. Varyings are used to pass data from the vertex shader to the fragment shader for color interpolation. Buffers are essential for transferring vertex data to the GPU for rendering, and attribute locations are assigned to specify how to extract and use this data efficiently.
The_Night_Watch
The text discusses the importance of systems programmers in dealing with complex technical challenges, emphasizing their unique skills in debugging and problem-solving. It contrasts the roles of systems programmers with other computer professionals like GUI designers and PHP developers, highlighting the critical nature of systems programming in challenging scenarios. The text humorously portrays the intense and sometimes absurd experiences of systems programmers, showcasing their indispensable role in addressing technical issues efficiently and effectively.
FreeType
FreeType is a software library for rendering fonts, available for free. It is designed to be small, efficient, and capable of producing high-quality font images. Users can find installation instructions, documentation, and ways to communicate with the FreeType team on their website.
A Freestanding Rust Binary
To create a freestanding Rust executable for operating system development, we need to disable linking to the standard library and define our own entry point function. By compiling for a bare metal target like thumbv7em-none-eabihf, we can avoid linker errors and run Rust code without an underlying operating system. Additional linker arguments are required for specific operating systems like Linux, Windows, and macOS to resolve linker errors and build the freestanding Rust binary successfully.
Manually linking Rust binaries to support out-of-tree LLVM passes
LLVM is a compiler infrastructure used by frontends like rustc to generate machine code. To add custom LLVM passes to a Rust binary, extra flags can be used during compilation to produce LLVM-IR and then link the binary properly using LLVM tools. By understanding how Rust's static libraries work and leveraging cargo for dependency management, custom LLVM passes can be integrated into Rust binaries efficiently.
The Rust Reference
The Rust compiler can generate different types of output artifacts, such as runnable executables, Rust libraries, dynamic libraries, and static system libraries. Dependencies between crates can be linked in various formats, such as rlib and dynamic library formats, following specific rules set by the compiler. Understanding how to specify output formats like --crate-type=bin or --crate-type=lib can help control the compilation process for Rust crates, while also considering options for linking C runtimes dynamically or statically based on target features.
Rust Compiler Development Guide
The Rust compiler processes and transforms your code for compilation. It uses different stages like lexing, parsing, and abstract syntax tree lowering. The compiler aims for correctness, performance, and supporting incremental compilation.
How to speed up the Rust compiler one last time
The author at Mozilla is concluding their work on speeding up the Rust compiler after several years of dedicated effort.
They wrote multiple blog posts detailing their performance optimizations and shared valuable lessons learned from the process.
The author expressed gratitude to those who supported their work and highlighted the importance of ongoing contributions to Rust's development.
How to speed up the Rust compiler in March 2024
In March 2024, updates on the Rust compiler's performance highlighted several key improvements. Changes like using a single codegen unit, marking Debug::fmt methods with #[inline], introducing a cache, and upgrading LLVM versions led to notable reductions in wall-time, binary size, and hash table lookups. Additionally, the availability of the Cranelift codegen backend for x86-64/Linux and ARM/Linux offers an alternative for faster compile times. While the author didn't contribute to speed improvements this time, overall performance from August 2023 to March 2024 showed reductions in wall-time, peak memory usage, and binary size, indicating steady progress in enhancing the Rust compiler's efficiency.
Zig Bits 0x4: Building an HTTP client/server from scratch
The text explains how to create an HTTP client and server from scratch using Zig >=0.11.
For the client, you need to set up requests, headers, and wait for responses.
The server part involves defining functions to handle requests and running the server to accept connections.
Do We Really Need A Link Step?
The author questions the need for a link step in native-code compilation for faster performance. They propose a "zero-link" approach where compilers directly write object code into the final executable file. This method could improve efficiency by avoiding unnecessary object files and incorporating symbol resolution within the executable itself.
jamiebuilds/the-super-tiny-compiler: :snowman: Possibly the smallest compiler ever
The Super Tiny Compiler is a simplified example of a modern compiler using easy-to-read JavaScript. It helps you understand how compilers work from start to finish. Compilers play a big role in the tools we use daily.
5 Days to Virtualization: A Series on Hypervisor Development
A series on hypervisor development for Intel processors with virtualization support will be published next week, covering topics like setting up a test environment, driver skeleton creation, and multi-processor initialization. The series aims to aid new readers in building, testing, and understanding type-2 hypervisor development using C programming language. Recommended reading and detailed explanations will be provided to enhance knowledge and understanding of virtualization concepts.
In-depth analysis on Valorant’s Guarded Regions
The text discusses how Valorant's anti-cheat system, Vanguard, uses innovative techniques to protect against memory manipulation by whitelisting threads and creating shadow regions. These methods involve cloning and modifying the game's paging tables to allow access to hidden memory without affecting performance. By implementing these advanced security measures, Vanguard effectively prevents cheats from bypassing its guarded regions.
Exploit Development: No Code Execution? No Problem! Living The Age of VBS, HVCI, and Kernel CFG
The text discusses various techniques used in exploit development, particularly focusing on targeting the Windows kernel. It mentions concepts like Hypervisor-Protected Code Integrity (HVCI) and how exploits can manipulate memory to execute attacker-controlled code in kernel mode. The text also delves into details like leaking kernel-mode memory, constructing ROP chains on the kernel-mode stack, and utilizing functions like NtQuerySystemInformation to escalate privileges and perform malicious actions in the system.
Reader
The Reader API by jina.ai helps extract clean, LLM-friendly text from web content, ensuring high-quality input for AI systems like agents and RAG. It can also search the web for the latest information to keep LLMs up-to-date, improve factuality, and reduce misinformation. Additionally, Reader can read images on webpages and PDFs, providing alt text for images and lightning-fast PDF processing, all available for free with flexible rate limits.
CheerpX versus WebContainers
CheerpX is a client-side virtualization technology for running x86 executables and operating systems in the browser without modifications or recompilation. It offers cost-effective, secure, and private execution of native code, making it suitable for various web-based applications. CheerpX stands out from other solutions by supporting any x86 executable and providing a robust two-tier emulator for efficient code execution.
Creating a Rootkit to Learn C
The text demonstrates creating a userland rootkit in C to hide malicious activities like network connections and files. By hooking into system calls like access() and write(), the rootkit can manipulate userland programs and evade detection by tools like netstat. The rootkit uses shared library injections and hooks to intercept and manipulate system calls, showcasing the power of C for malicious activities.
Picsart-AI-Research/LIVE-Layerwise-Image-Vectorization: [CVPR 2022 Oral] Towards Layer-wise Image Vectorization
The text discusses a new method called LIVE for generating SVG images layer by layer to fit raster images. LIVE uses closed bezier paths to learn visual concepts in a recursive manner. Installation instructions and references for the method are provided in the text.
Udacity CS344: Intro to Parallel Programming
Intro to Parallel Programming is a free online course by NVIDIA and Udacity teaching parallel computing with CUDA. It's for developers, scientists, engineers, and students looking to learn about GPU programming and optimization. The course is self-paced, requires C programming knowledge, and offers approximately 21 hours of content.
CS 361: Systems Programming
The Systems Programming course at UIC includes assigned readings, video lectures, labs, and quizzes scheduled throughout the week. Students can access additional resources and submit assignments through the course gradescope page. Office hours, content quizzes, discussions, and exams are held on specific days via Zoom and YouTube.
Resolving Rust Symbols
Linking combines object files into an executable or shared library in Rust. The linker resolves symbols and dependencies between object files. Rust prefers static linking to create a single distributable binary with all dependencies included.
When FFI Function Calls Beat Native C
David Yu performed a benchmark comparing different Foreign Function Interfaces (FFI) for function calls. LuaJIT's FFI was found to be faster than native C function calls due to efficient dynamic function call handling. Direct function calls, like those used by LuaJIT, can outperform indirect calls routed through a Procedure Linkage Table (PLT).
Cap'n Proto, FlatBuffers, and SBE
FlatBuffers is a new serialization protocol released by Google engineers, similar to Cap’n Proto. Cap’n Proto allows random access using pointers, while FlatBuffers uses offsets stored in tables for random access. Protobufs, Cap’n Proto, and FlatBuffers have custom schema languages and different features for data serialization and access.
A Database Without Dynamic Memory Allocation
TigerBeetle, a database written in Zig, does not allocate memory dynamically after startup. It uses static memory allocation for all data structures, avoiding performance issues and use-after-free bugs. This approach allows for better predictability, easier handling of overload, and efficient resource management.
Wizard Zines Collection!
Julia offers programming zines with black and white covers for free and colored covers for purchase. The zines can be bought individually for $10-$12 each or as a whole collection. Additionally, there are free posters and a weekly comic subscription available.
Aggregating Millions of Groups Fast in Apache Arrow DataFusion 28.0.0
Apache Arrow DataFusion version 28.0.0 now offers faster parallel aggregation for queries with many groups. The improvements aim to enhance user experiences by generating insights more efficiently. These enhancements bring DataFusion closer to the grouping speed of DuckDB.
Problems of C, and how Zig addresses them
This blog post discusses issues with C and how Zig addresses them through features like comptime evaluations and improved memory management. Zig offers solutions like error handling improvements and treating everything as an expression, making it a modern alternative to C with enhanced functionalities. The comparison highlights Zig's advantages in areas such as memory management, error handling, and expressive coding practices.
How to use hash map contexts to save memory when doing a string table
The text explains how to save memory when building a string table using hash map contexts. By adapting context APIs, only indexes are stored in the table, reducing memory usage. This method can save 117 KB of memory for a string table with 10 thousand entries.
resume.txt
Andrew Kelley is a programmer with 16 years of experience in software development and a passion for open-source projects. He has worked on various music-related software like the Genesis DAW and libgroove, contributing patches to libav and ffmpeg. Additionally, he has experience in low-level systems, custom algorithm creation, and designing user interfaces.
Leslie Lamport
Leslie Lamport wrote several papers on verifying and specifying concurrent systems using TLA. He discovered algorithms through formal derivation and emphasized mechanical verification of concurrent algorithms. His work influenced the development of the TLAPS proof system.
Indices and tables
CompilerGym is a library for reinforcement learning in compiler tasks. It helps ML researchers work on optimization problems and allows system developers to create new tasks for ML research. The goal is to use ML to make compilers faster.
448997590_1496256481254967_2304975057370160015_n
The LLM Compiler is a suite of pre-trained models designed for code optimization tasks, based on Code Llama. It has been trained on a large corpus of LLVM-IR and assembly code to enhance compiler behavior understanding. The release of LLM Compiler aims to support further research in compiler optimization for both academia and industry.
Bare Bones
This text explains how to create an operating system by first cross-compiling and using existing technology. It guides you through writing a kernel in C or C++, creating a bootloader, and linking the kernel for x86 systems. Following these steps ensures your operating system can be loaded and executed correctly.
The Graphics Codex
"The Graphics Codex" is a comprehensive resource for computer graphics, offering essential information on 3D rendering and shading. It includes equations, diagrams, and programming projects, with free updates every month. Written by expert Morgan McGuire, it is a valuable tool for learning and reference in the field of computer graphics.
Notes on partial borrows
The text discusses limitations of the Rust borrow checker and proposes solutions for creating references that borrow from specific subsets of a type. Two approaches, "View types" and "Reference views," are explored to address these limitations and provide more flexibility in borrowing subsets of fields with different lifetimes and mutability. The discussion includes examples, subtyping implications, monomorphization considerations, and the need to update Rust's aliasing model to accommodate view references accessing discontiguous memory regions.
Dioxus Labs + “High-level Rust”
An article criticized Rust's gamedev hype, but its popularity stems from meeting modern programming needs like speed and safety. Efforts are underway to enhance Rust's capabilities for various industries and improve compile times significantly. Proposed enhancements include incremental linking, parallel frontend, and macro expansion caching to make Rust more efficient for developers.
Compile-Time Configuration For Zig Libraries
To expose compile-time configuration options in Zig libraries, developers can use global declarations in the root source file or through Zig's build system. By setting configuration flags, developers can customize behavior such as enabling or disabling assertions in library code. Compile-time configuration can improve performance by allowing certain checks to be done at compile-time rather than runtime.
Generics
Generics in Zig allow for creating data structures and algorithms that can work with different types. By using generics, code can be written once and reused with various data types. Zig's approach to generics involves leveraging compile-time metaprogramming capabilities.
Zig's HashMap - Part 1
Zig's std.HashMap implementation relies on two key functions: hash and eql. The documentation outlines various hash map types and their functionalities, including std.HashMapUnmanaged. AutoHashMap can automatically generate hash functions, but there are limitations, and custom contexts can be provided for more complex keys.
Zig Parser
The Zig Parser is a crucial part of the Zig compiler internals, responsible for constructing an abstract syntax tree from a stream of tokens. The parser uses a struct called Parser to manage the internal state of the parse operation, accumulating errors and building up AST nodes. Understanding the structure of an AST node and the data pattern is essential for comprehending how the parser works and the subsequent stages of the compiler. The AST node data is stored in various locations such as the token stream, the node list, and the extra data list, with specific structures and indexes used to access information about AST nodes like function declarations and prototypes.
Causal ordering
Causal ordering is essential for understanding distributed systems, where events may not have a clear time order. This concept helps determine the causal relationship between events in a system. It enables reasoning about causality, leading to simpler solutions in distributed computing.
Assorted thoughts on zig (and rust)
Zig is simpler than Rust and offers similar features through compile-time execution. Rust provides strong type safety guarantees for generic functions, while Zig lacks automatic type constraint documentation and may face challenges with IDE support. Zig excels in custom allocators and handling out-of-memory errors, while Rust excels in preventing memory leaks and resource management.
Columnar kernels in go?
Over the winter I'm going to be adding a columnar query engine to an existing system written in go.
An opinionated map of incremental and streaming systems
The text discusses various design choices and characteristics of incremental and streaming systems. It highlights the core idea of these systems, which is to process inputs to generate outputs efficiently. The systems are categorized based on unstructured vs structured design, high temporal locality vs low temporal locality workloads, internal consistency vs internal inconsistency, and eager vs lazy computation approaches. The text explains the advantages and disadvantages of each design choice and provides examples of systems that fall into different categories. Additionally, it emphasizes the importance of understanding these design choices in selecting the appropriate system for specific workloads.
Internal consistency in streaming systems
The text discusses the importance of internal consistency in streaming systems. It explains how eventual consistency can lead to incorrect outputs and the need for systems to wait for all relevant inputs before emitting results. Maintaining internal consistency ensures correct outputs and prevents confusion between changes and corrections.
Pain we forgot
The text discusses the challenges in programming and the need for more user-friendly tools. It emphasizes the importance of improving feedback loops, running code smoothly, and creating more helpful programming environments. The author suggests rethinking traditional tools and approaches to make programming more accessible and efficient.
Have you tried rubbing a database on it?
HYTRADBOI was a conference featuring lightning talks on innovative uses of databases for solving problems. Talks included topics like building data-centric apps, realtime machine learning, and interactive databases. The event focused on embracing new solutions and fostering professional behavior among attendees.
The shape of data
The text discusses the importance of having a clear and consistent data notation in programming languages like Clojure. It emphasizes the advantages of a notation that closely aligns with the in-memory representation of data, making it easier for developers to work with and understand data structures. Additionally, it suggests that a well-designed data model and notation are crucial for efficient data manipulation and code analysis.
Prospecting for Hash Functions
The text discusses the process of designing non-cryptographic integer hash functions, exploring different operations and constraints to create effective hash functions. It also compares various 32-bit hash functions and their bias levels, highlighting the search for high-quality hash functions with minimal bias for both 32-bit and 64-bit integers.
The Missing Zig Polymorphism / Runtime Dispatch Reference
The text discusses how Zig lacks built-in polymorphism features like interfaces or virtual methods. It explores creating polymorphism using existing language features in Zig. The author provides a detailed guide on implementing polymorphism in Zig, focusing on dynamic dispatch using function pointers.
How To Become A Hacker
The text explains what it means to be a hacker, focusing on problem-solving, creativity, and a willingness to share knowledge within the hacker culture. It emphasizes the importance of developing a hacker mindset, skills, and dedication through self-education and a passion for solving new problems. The hacker culture values intelligence, hard work, and a sense of community, with an emphasis on learning and sharing information to advance the collective knowledge of hackers.
the rr debugging experience
rr is a debugging tool for Linux that records failures for deterministic replay under gdb. It helps debug real applications efficiently and supports reverse execution for finding bugs. rr aims to make debugging easier with low overhead and powerful features like hardware data watchpoints.
Text Buffer Reimplementation
The Visual Studio Code 1.21 release includes a new text buffer implementation that improves performance in terms of speed and memory usage. The previous implementation used an array of lines, but it had limitations such as high memory usage and slow file opening times. The new implementation uses a piece table data structure, which allows for better memory usage and faster line look-up. Additionally, the implementation uses techniques such as caching for faster line lookup and a balanced binary tree for efficient searching. Benchmarks showed that the new implementation outperformed the previous line array implementation in terms of memory usage, file opening times, and reading operations.
What Is The Minimal Set Of Optimizations Needed For Zero-Cost Abstraction?
Rust and C++ offer "zero-cost abstractions" where high-level code compiles to low-level code without added runtime overhead, but enabling necessary compiler optimizations can slow down compilation and impact debugging. The challenge is to find the minimal set of optimizations that maintain zero-cost abstractions while improving build speed and debug information quality. Balancing fast debuggable builds with zero-cost abstractions is crucial for performance and developer experience in languages like Rust and C++.
Using ASCII waveforms to test hardware designs
Using expect tests automates the validation of code output, detecting errors efficiently. Jane Street uses Hardcaml in OCaml for hardware development, simplifying testbench creation. Waveform expect tests help visualize hardware behavior, improving development workflows.
Rust 2019 and beyond: limits to (some) growth.
The text discusses the need for controls and policies to manage the growth limits of technical artifacts and the strains on individuals in the Rust project. It emphasizes the importance of acknowledging and addressing these limits to prevent potential crises or dysfunction in the future. The author suggests implementing controls, such as hard limits and moderation strategies, to maintain a healthy and sustainable project environment.
Your ABI is Probably Wrong
The text discusses how most ABIs have a design flaw that harms performance by passing large structures inefficiently. Different ABIs handle passing large structures differently, but they all repeat the same mistakes. A correctly-specified ABI should pass large structures by immutable reference to avoid unnecessary copies.
GitHub - sirupsen/napkin-math: Techniques and numbers for estimating system's performance from first-principles
The project "Napkin Math" aims to provide resources and techniques to estimate system performance quickly and accurately. It includes examples like estimating memory reading speed and storage costs for applications. The best way to learn this skill is through practical application, with the option to subscribe for regular practice problems. Detailed numbers and cost estimates are provided, along with compression ratios and techniques to simplify calculations. The project encourages user participation to enhance and refine the provided data and tools for napkin math calculations.
Don't write bugs
Effective programmers should focus on preventing bugs rather than debugging them. Re-reading code frequently can help reduce the number of errors. Writing bug-free code is achievable with practice and attention to detail.
technicalities: "not rocket science" (the story of monotone and bors)
The text discusses the development of a program called bors that enforces the "Not Rocket Science Rule" of maintaining a code repository that always passes tests. Bors automates integration testing and ensures code changes are only merged if they pass tests, preventing broken code from being merged. This system has been found to be extremely beneficial for software projects, ensuring a stable and reliable codebase.
Why is Python slow
Python's performance issues stem from spending most time in the C runtime, rather than the Python code itself. Pyston focuses on speeding up the C code to improve performance. Suggestions to improve Python's speed by using other JIT techniques overlook the fundamental issue of optimizing C code.
Design duality and the expression problem
The text discusses the concept of design duality in programming, focusing on the trade-offs between objects and data representations. It highlights the importance of making conscious design choices when introducing new types, whether as data, objects with extensible implementations, or abstract data types with restricted extensibility. The author emphasizes the need for programming languages to better support and encourage these design considerations.
Random Thoughts On Rust: crates.io And IDEs
The author shares experiences with Rust, praising cargo and crates.io for easy code distribution. They highlight the need for improved library discovery on crates.io and discuss the potential for better IDE support in Rust projects. Despite challenges like type inference, Rust's design enables advanced IDE features that can enhance coding efficiency.
John Carmack on Inlined Code
Consider inlining functions that are only called in one place for efficiency. Simplify code structure to reduce bugs and improve performance. Emphasize consistent execution paths over avoiding minor optimizations.
A Few Billion Lines of Code Later: Using Static Analysis to Find Bugs in the Real World
The text discusses the development and commercialization of a bug-finding tool that can identify errors in large amounts of code. It highlights the challenges faced in finding and addressing various types of bugs, such as memory corruption and data races, across different programming systems. The tool's effectiveness in uncovering bugs in complex codebases emphasizes the importance of bug detection for improving software quality.
What is Systems Programming, Really?
The term "systems programming" combines low-level programming and systems design. It involves creating and managing complex components, often focusing on machine implementation details. Over time, the distinction between systems programming and other programming languages has become less clear.
Mitchell Hashimoto
Mitchell Hashimoto is an advisor at Polar and shares insights on technical projects, Zig programming, and automation on his website. He discusses various topics like GitHub pull requests, Zig build system, and AI growth through cloud lens. Mitchell's writing covers a range of technical subjects and his experiences in the startup world.
UB Might Be a Wrong Term for Newer Languages Apr 2, 2023
The author suggests that using the term "undefined behavior" in newer languages like Zig and Rust may not be the best choice due to differences in semantics. In C, implementations can define some behaviors left undefined by the standard, but in Rust and Zig, any program showing undefined behavior is considered invalid. The author proposes using terms like "non-trapping programming error" or "invalid behavior" to better convey the intended semantics in these languages.
What Every C Programmer Should Know About Undefined Behavior #1/3
This blog post explains that many seemingly reasonable things in C actually have undefined behavior, leading to common bugs in programs. Undefined behavior in C allows for optimizations that improve performance but can result in unexpected outcomes like formatting your hard drive. Understanding undefined behavior is crucial for C programmers to prevent potential issues and improve code efficiency.
The Rustonomicon
The Rustonomicon is a book for understanding Unsafe Rust programming details. It complements The Rust Programming Language by delving into combining language pieces and potential issues. The book covers topics like (un)safety, creating safe abstractions with unsafe primitives, and working with memory, but does not provide exhaustive API details.
So Many New Systems Programming Languages II
The text discusses new systems programming languages like Rust, Zig, and Odin, highlighting their safety features and syntax. These languages offer improved memory management and safety compared to older languages like C and C++. Rust, in particular, stands out for its memory safety, threading support, and borrow checker.
zackoverflow
Zack, the author, enjoys building things and delving into the inner workings of systems and computers for dopamine. He works on the Bun JavaScript runtime and creates music when not coding. Zack invites anyone to chat through his open calendar link.
From Theory To Implementation
Physically Based Rendering is a widely-used textbook in computer graphics that combines theory with practical implementation for creating realistic images. The book, authored by industry experts, offers cutting-edge algorithms and ideas, including GPU ray tracing, to help readers design advanced rendering systems. Both the third and fourth editions of the book are available online for free.
Speech-to-text models
Speech-to-text AI enhances communication and accessibility by transcribing spoken words into text accurately and efficiently. Machine learning and AI advancements have significantly improved the accuracy and adaptability of speech-to-text systems. These technologies open up new possibilities for inclusive and effective communication across various industries.
Ray Tracing in One Weekend
"Ray Tracing in One Weekend" introduces readers to the concept of ray tracing through a step-by-step guide to creating a ray tracer that produces images. The document covers topics such as sending rays into the scene, ray-sphere intersection, shading, and reflection. It explains the mathematical aspects behind ray tracing, including formulas for sphere intersections and normal vectors. The guide progresses from creating a simple image of a sphere to more complex scenes, providing insights into the coding process and considerations for optimizing the rendering process.
Untangling Lifetimes: The Arena Allocator
The text discusses the arena allocator as an alternative to traditional manual memory management in C, addressing issues with malloc and free. The arena allocator simplifies memory allocation and deallocation by grouping lifetimes together in a single block of memory. It provides a more efficient and manageable way to handle memory usage in codebases compared to the malloc and free approach.
Tree-Structured Concurrency — 2023-07-01
Structured concurrency is a programming concept that ensures clear control flow in concurrent programs. In the context of async Rust, it guarantees properties like cancellation propagation, which means that dropping a future will also cancel all nested futures. The text discusses examples of unstructured and structured concurrency patterns, emphasizing the importance of applying structured concurrency to improve program correctness and maintainability. It also mentions the need for more API support to fully achieve structured concurrency in async Rust, suggesting practical approaches like using task queues or adopting the smol model for task spawning. Overall, structured concurrency provides a way to reason about async Rust programs effectively and enhance their reliability.
BSTJ 57: 6. July-August 1978: The UNIX Time-Sharing System. (Ritchie, D.M.; Thompson, K.)
The UNIX Time-Sharing System is a versatile operating system with unique features. It runs on Digital Equipment Corporation computers and emphasizes simplicity and ease of use. UNIX has been widely adopted for research, education, and document preparation purposes.
Principles of compiler design
This text is about a book on compiler design principles. The book is authored by Jeffrey D. Ullman and contains 604 pages. It includes bibliographical references, but access to the EPUB and PDF versions is not available.
Mapping the whole internet with Hilbert curves
The author mapped the internet using Hilbert curves to visualize IP addresses. The curves help display the vast network structure in a more comprehensible way. The scan revealed interesting patterns and changes in IP address allocations over time.
xorvoid
Anthony Bonkoski, a computer enthusiast and engineer, shares his experiences in programming and working in quantitative finance. He enjoys working on various projects and has expertise in low-level programming, distributed systems, and reverse-engineering. Currently taking a break from full-time work, he is open to part-time consulting projects and enjoys writing and exploring new interests.
You own your data, in spite of the cloud
The text discusses the benefits of local-first software, emphasizing ownership and control of data while also enabling seamless collaboration. It compares traditional cloud apps with new approaches that prioritize user ownership and real-time collaboration. The focus is on developing software that combines the convenience of cloud apps with the data ownership of traditional software.
Writing CUDA Kernels for PyTorch
The text shows the thread distribution on different streaming multiprocessors (SM) in CUDA. Threads are organized into warps, lanes, and specific thread numbers within each SM. This information is crucial for optimizing CUDA kernels in PyTorch.
999 crates of Rust on the wall
The author compared popular crates on crates.io to their upstream repositories to improve supply chain security. Most top crates matched their repositories, but some had issues like missing VCS info or build failures. Future work includes extending this analysis to all crates on crates.io and improving publishing processes for better security.
Arithmetic functions
BQN's arithmetic functions mirror mathematical notation and apply element-wise to arrays. BQN supports basic arithmetic operations like addition, subtraction, multiplication, division, exponentiation, and root functions. Character arithmetic is a distinctive feature allowing manipulation of characters with symbols like + and -.
An interactive study of queueing strategies
This text explores different queueing strategies for handling requests, emphasizing the importance of prioritizing requests effectively to prevent dropping important ones. It introduces concepts like FIFO and priority queues, as well as active queue management techniques to optimize request processing. Understanding these strategies can help in efficiently managing queues and improving overall system performance.
ethereumbook/04keys-addresses.asciidoc at develop · ethereumbook/ethereumbook · GitHub
This chapter introduces public key cryptography used in Ethereum for securing ownership of funds through private keys and addresses. Public keys are derived from private keys and are represented as points on an elliptic curve. Ethereum addresses are unique identifiers generated from public keys using the Keccak-256 hash function.
Accidentally Turing-Complete
The document "Accidentally Turing-Complete" explores various unexpected systems and technologies that unintentionally exhibit Turing completeness, a property that allows them to perform any computation. Examples include C++ templates, TypeScript, Java generics, X86 mov instructions, Magic: The Gathering card game, HTML5, Minecraft, Dwarf Fortress game, SQL, Apache Rewrite Rules, Pokemon Yellow game, Scala type system, MediaWiki templates, Little Big Planet game, Sendmail, Vim Normal-Mode, Border Gateway Protocol (BGP), Excel, Super Mario World glitches, PowerPoint, Font Shaping, JBIG2 Image Compression, and Stupid RDMA NICs. The document showcases how these diverse systems, from games to internet protocols, can unexpectedly demonstrate the computational power of Turing completeness.
Problems with BQN
BQN has issues with incoherent monad-dyad pairs and train structures, making code readability and implementation challenging. Modifications like the Constant modifier ˙ attempt to address these challenges. However, there are still limitations in tacit code construction and array reductions that impact the language's usability.
The borrow checker within
The text discusses improvements to Rust's borrow checker to align better with its core design ethos of mutation xor sharing. These changes aim to make Rust code patterns feel more intuitive and work seamlessly with the borrow checker's rules. The proposed enhancements include features like conditional return references, view types, and addressing phased initialization issues.
How should I read type system notation?
A type system in programming languages follows rules for expressions and types. Typing rules are written as relationships between expressions and their types for checking and inferring types. Contexts are used to keep track of variable types in type judgments.
Writing a Simple Garbage Collector in C
Summary:
The text explains how to implement a simple garbage collector in C by writing a memory allocator function that manages free and used memory blocks using linked lists. The garbage collection algorithm involves scanning memory regions to mark blocks in use and free those not in use. The collector function collects unused memory blocks, making the heap scanning code simpler and faster.
A decade of developing a programming language
The author spent a decade developing the programming language Inko, transitioning from gradual to static typing and using Rust for the compiler. Recommendations include avoiding gradual typing, self-hosting compilers, and focusing on functionality over performance when building a new language. Building a language for long-term use is a time-consuming process that requires prioritizing user needs over technical complexities.
The Rust I Wanted Had No Future
The author preferred certain design choices in early Rust over the current state, such as the treatment of certain language features and performance considerations. They express a desire for a simpler, less performance-focused language with different priorities than those commonly held in the Rust community. The author reflects on their preferences for language design and the trade-offs they would have made for a more straightforward and expressive programming experience.
The Garbage Collection Handbook
The Garbage Collection Handbook is a comprehensive guide on automatic memory management, covering modern techniques and challenges faced by programmers. This second edition updates the handbook with insights from over 60 years of research and development in the field. It is essential reading for programmers looking to understand and navigate the complexities of garbage collection in modern programming languages.
essentials-of-compilation
The text discusses the implementation of compilers for different programming languages, covering topics such as syntax definitions, interpreter extensions, and x86 assembly translation. It emphasizes simplifying the compiler process for readers by using a straightforward language and providing step-by-step guidance on compiler development. Additionally, it introduces new language features like Booleans, conditionals, and tuples, expanding the capabilities of the compilers being built.
PRACTICAL COMPILER CONSTRUCTION
"Practical Compiler Construction" is a textbook on writing compilers with annotated source code. The second edition is now available in print with improvements and bug fixes. The book covers compiler construction concepts and advanced techniques for optimizing code.
A Distributed Systems Reading List
This reading list covers materials for understanding distributed systems design and challenges. It includes resources on topics like latency, Amazon's organizational culture, Google's cutting-edge technologies, consistency models, theory, languages, tools, infrastructure, storage, Paxos consensus, and gossip protocols. The list aims to help readers adapt their thinking to effectively tackle distributed system complexities.
An Introduction to Assembly Programming with RISC-V
This text provides information about a resource related to RISC-V programming. The ISBN number for this resource is 978-65-00-15811-3. It is authored by riscv-programming.org.
Microsoft PowerPoint - SRAM Architecture
The text discusses the architecture of Static Random Access Memory (SRAM) cells, focusing on their read and write operations, sizing considerations, and column circuitry. SRAM cells store data using cross-coupled inverters, with specific steps for reading and writing data. Column circuitry includes bitline conditioning, sense amplifiers, and multiplexing for efficient data access.
MLIR: A Compiler Infrastructure for the End of Moore's Law
MLIR is a versatile compiler infrastructure designed to address software fragmentation and improve compilation for different hardware. It aims to reduce the cost of building domain-specific compilers and facilitate the connection of existing compilers. MLIR offers a standardized approach to code generation and optimization across various application domains and hardware targets.
MLIR — Getting Started
The text is a guide titled "MLIR — Getting Started" by Math ∩ Programming available on www.jeremykun.com.
Chapter 2 Basics of SIMD Programming
The text explains how to organize data for SIMD operations and provides examples of SIMD-Ready Vectors. It also discusses the relationship between vectors and scalars in SIMD programming. Built-in functions for VMX instructions and SIMD operation principles are outlined in the text.
Matrix multiplication in Mojo
The text discusses matrix multiplication in Mojo. It is written by modular.com and can be found on docs.modular.com.
Matrix Multiplication on CPU
The text is about matrix multiplication on a CPU. The author is Marek Kolodziej and the domain is marek.ai.
How to Optimize a CUDA Matmul Kernel for cuBLAS-like Performance: a Worklog
The text is a worklog by Simon Boehm about optimizing a CUDA Matmul Kernel for cuBLAS-like performance. It can be found on the domain siboehm.com.
Where Vim Came From
Vim is a popular text editor with a long history tracing back to the Unix epoch. Its development started in 1988 and evolved from the "wq text editor" concept. Vim's success is attributed to its features and the gradual accumulation of good ideas over time.
Building and operating a pretty big storage system called S3
Dr. Werner Vogels shares insights from working on Amazon's S3 storage system, highlighting the scale and unique challenges faced. S3's design incorporates innovative strategies to efficiently handle vast amounts of data across millions of hard drives while prioritizing customer experience. Vogels emphasizes the need for a broader perspective on software systems and the rewarding journey of scaling as an engineer at Amazon.
Structure and Interpretation of Computer Programs, 2nd ed.
The text discusses key concepts in programming, such as primitive expressions, means of combination, and means of abstraction. It highlights the role of the environment in determining the meaning of symbols in expressions. The evaluation process involves reducing expressions to procedures applied to arguments, leading to a deeper understanding of programming concepts.
Terry A. Davis
Terry A. Davis, an American electrical engineer and programmer, created TempleOS, a public domain operating system. Despite his mental health challenges, Davis gained an online following for his unique work and beliefs. His legacy continues to be remembered through documentaries and online discussions.
A Gentle Introduction to LLVM IR
Learning LLVM IR can be beneficial for generalist working programmers to understand what their compiler is doing to create highly optimized code. LLVM IR is well-documented and can be treated as a slightly weird programming language. It is strongly typed and requires explicit type annotations. LLVM IR is a static single assignment form (SSA) IR and has properties that make optimizations simpler to write. It supports control flow operations, arithmetic instructions for different types, and memory operations. There are also LLVM intrinsics available for specific functions. However, some parts of LLVM's semantics, such as undefined behavior and pointer provenance, can be challenging to navigate.
þÿThe Little Book of Deep Learning
I'm sorry, but there is no content provided to summarize. If you have any text or information you would like me to summarize, please provide it so I can assist you.
How to round to 2 decimals with Python? [duplicate]
To round a number to 2 decimals in Python, the usual method is using round(value, significantDigit), but it can behave unexpectedly when the digit before the one being rounded is a 5. To address this, a workaround involves adding a small value to ensure proper rounding. This method allows for traditional rounding commonly used in statistics without needing to import additional libraries like Decimal. By incorporating this workaround into a function, you can achieve the desired rounding results without encountering the issue with numbers ending in 5.
Rounding floats with f-string [duplicate]
Using %-formatting, I can specify the number of decimal cases in a string:
x = 3.14159265
print('pi = %0.2f' %x)
This would give me:
pi = 3.14
Is there any way of doing this using f-strings in ...
Latent Interfaces
In a career shift, the author is launching Latent Interfaces to apply expertise in design, prototyping, and development to complex data challenges. They share insights into a genomic data project, emphasizing the importance of Python skills alongside JavaScript. The document showcases the creation of intuitive data interfaces and the design process involving both digital and physical tools. Additionally, the author discusses the significance of well-designed APIs like StabilityAI and the potential for future collaborations in data visualization projects.
Hypercomputation
Hypercomputation and super-Turing computation involve models of computation that can produce non-Turing-computable outputs. Introduced in the early 1990s, super-Turing computing is inspired by neurological and biological systems and serves as the foundation for Lifelong Machine Learning. Hypercomputation, a field introduced in the late 1990s, includes philosophical constructs and aims to compute functions beyond what a Turing machine can. The Church-Turing thesis states that any "computable" function can be computed by a Turing machine, but hypercomputers can compute functions that are not computable in the Church-Turing sense. Various hypercomputer models exist, ranging from theoretical concepts like oracle machines to more plausible models like quantum computing. Some proposals suggest that hypercomputation may be achievable through systems like neural networks or analog computers. Critics argue that hypercomputation is not physically realizable.
How Netflix Really Uses Java
The discussion at Netflix delves into how Java is utilized within the company's architecture, highlighting their transition to Java 17 and ongoing testing with Java 21. The move to newer Java versions resulted in significant performance improvements, such as 20% better CPU usage with Java 17. Additionally, the implementation of GraphQL Federation and virtual threads in Java 21 are key advancements that are expected to impact the way code is written and scaled within Netflix's Java stack. The company's shift from Java 8 to Java 17 and the ongoing evolution of their technology frameworks and tooling, particularly focusing on Spring Boot, demonstrate their commitment to staying current with Java developments.
Scheduling Internals
The document delves into the concept of concurrency in programming, exploring how tasks can be handled concurrently using different methods like threads, async I/O, event loops, and schedulers. It discusses the challenges and benefits of each approach, illustrating examples in C code to demonstrate the practical implementations. The text covers topics like preemptive and non-preemptive schedulers, implementation details in languages like Go and Rust, as well as the use of event loops for efficient task handling. It also touches on the importance of understanding program state management and the impact on task execution in concurrent programming.
tns
This document, entitled "tns", explores the concept of network states and their potential to replace traditional nation states. The author argues that a network state is a social network with a moral innovation, a sense of national consciousness, and a recognized founder, among other features. The document also delves into the history of political power and technological truth, and how the network state is the next Leviathan. The author provides examples of positive and negative syntheses of the network and state and discusses the potential for startup societies and network states to maintain liberal values in an illiberal world.
Competitive Programmer's Handbook
The article discusses various algorithms and data structures used in computer programming, such as Kadane's algorithm, binary indexed trees, segment trees, Dijkstra's algorithm, and Floyd's algorithm. The author also explains concepts like successor graphs, index compression, and minimum spanning trees. The time complexity of each algorithm is also discussed.
Writing an OS in Rust
This blog series provides tutorials on creating a small operating system in the Rust programming language. Each post includes all the necessary code and is accompanied by a corresponding GitHub repository. The series covers topics such as creating a Rust executable without linking the standard library, building a bootable disk image, implementing VGA text mode, performing unit and integration testing, handling CPU exceptions, setting up the interrupt descriptor table, implementing paging and heap allocation, and exploring cooperative multitasking and the async/await feature of Rust. The posts also include status updates and information on supporting the author.
Ever wanted to make your own programming language or wondered how they are designed and built?
Crafting Interpreters is a book that provides everything you need to create your own programming language. It covers both high-level concepts like parsing and semantics, as well as technical details such as bytecode representation and garbage collection. The book guides you through building a language from scratch, including features like dynamic typing, lexical scope, functions, classes, and inheritance. It is available in multiple formats, including print, ebook, and online for free. The author, Robert Nystrom, is an experienced language developer who currently works at Google on the Dart language.
ageron/handson-ml3: A series of Jupyter notebooks that walk you through the fundamentals of Machine Learning and Deep Learning in Python using Scikit-Learn, Keras and TensorFlow 2.
The ageron/handson-ml3 project is designed to teach the fundamentals of Machine Learning using Python. It includes example code and exercise solutions from the third edition of the book "Hands-on Machine Learning with Scikit-Learn, Keras and TensorFlow." The project provides options for running the notebooks online, using a Docker image, or installing the project on your own machine. It also addresses frequently asked questions about Python versions, SSL errors, and updating the project. The project has received contributions from various individuals, including reviewers, contributors to exercise solutions, and supporters from the Google ML Developer Programs team.
Software Development Trends 2023/2024 - Vol. 2.
The document provides a summary of important software development trends observed in 2023 that are likely to continue into 2024. It includes information on technology roadmaps, the state of DevOps, cloud computing, serverless technology, databases, and more. Some key insights from the document include the value drivers and risks associated with adopting software engineering technologies, the impact of generative cultures and user-focused teams on performance, and the increasing adoption of serverless solutions. Additionally, the document highlights the need for multi-cloud skills development and the most in-demand cloud skills for 2023.
Getting Started with Elastic Stack 8.0
The Elastic Stack consists of Elasticsearch for data storage and search, Kibana for visualization, and tools like Beats and Logstash for data collection and transformation. Beginners can learn about key topics like indexing, searching, and managing data in Elasticsearch through various chapters in the book. Kibana is essential for interacting with data and building solutions on the Elastic Stack.
fastai/fastbook: The fastai book, published as Jupyter Notebooks
The fastai book, published as Jupyter Notebooks, provides an introduction to deep learning, fastai, and PyTorch. It is copyright Jeremy Howard and Sylvain Gugger, and a selection of chapters is available to read online. The notebooks in the repository are used for a MOOC and form the basis of the book, which is available for purchase. The code in the notebooks is covered by the GPL v3 license, while the other content is not licensed for redistribution or change. It is recommended to use Google Colab to access and work with the notebooks. If there are any contributions or citations, copyright is assigned to Jeremy Howard and Sylvain Gugger.
Pen and Paper Exercises in Machine Learning
This is a collection of (mostly) pen-and-paper exercises in machine learning.
The exercises are on the following topics: linear algebra, optimisation,
directed graphical models, undirected graphical models, expressive power of
graphical models, factor graphs and message passing, inference for hidden
Markov models, model-based learning (including ICA and unnormalised models),
sampling and Monte-Carlo integration, and variational inference.
Spaces using openai/whisper-large-v2 232
Whisper is a pre-trained model for automatic speech recognition (ASR) and speech translation. It was trained on 680k hours of labelled data and demonstrates strong generalization abilities without the need for fine-tuning. The large-v2 model, trained for 2.5x more epochs with added regularization, offers improved performance. The models can be used for transcription and translation tasks, with context tokens indicating the language and task. While the models show robustness and accuracy in many languages, they may exhibit limitations such as generating repetitive texts and hallucinations. The models have potential applications in accessibility tools but also raise concerns about dual use and surveillance capabilities.
Subcategories
- algorithms (2)
- computer_architecture (138)
- computer_graphics (28)
- courses (4)
- cryptography (6)
- databases (11)
- distributed_systems (10)
- game_development (26)
- hardware_engineering (13)
- history (25)
- networking (5)
- parallel_computing (28)
- programming_languages (149)
- signal_processing (3)
- software_architecture (1)
- software_development (267)
- systems_programming (141)
- theory (320)
- tools (5)
- web_technologies (1)