HN repeatedly recommends it as an entertaining, mind-opening talk on allocator design and composable generic programming.
Topics › Software Engineering & Languages
The best c, c++, rust, go & systems languages videos, according to Hacker News
161 videos about c, c++, rust, go & systems languages that Hacker News commenters keep pointing each other to, ranked by how many separate months they were recommended. Part of Software Engineering & Languages.
HN returns to it for years as an elegant introduction to writing a lexer that is easy to follow even without a parsing background.
HN repeatedly cites it as the definitive explanation of SwissTable, the design behind Abseil, Rust's hash map and Go's maps.
HN treats it as the go-to explanation of ECS, valuable even for people who don't use Rust.
A perennial favorite, recommended as proof that expressive modern C++ can compile to efficient code even on tiny retro hardware.
HN programmers recommend it, and the Jai series that followed, for the game-industry view on replacing C++ and for watching a language being invented.
It is the go-to talk HN points to for data-oriented design and hardware-aware performance thinking, despite Acton's blunt style.
HN recommends it as the one long programming video worth watching, a provocative and influential take on C.
The canonical recommendation for learning Go concurrency, praised as entertaining and clarifying when to use channels versus mutexes.
HN people cite it constantly in C versus C++ debates as the case for teaching modern C++ idioms rather than C first.
HN repeatedly recommends it as the definitive introduction to Zig straight from its author, and links to it whenever Zig's design choices come up.
A perennial recommendation for anyone learning performance optimization, cited whenever hash tables, cache behavior or STL containers come up.
HN treats it as the standard introduction to Zig by its creator, with some calling it among the best talks they have seen.
HN commenters cite it whenever zero-cost abstraction claims come up, especially for why unique_ptr is not free on some ABIs.
HN people point to it for rrb-trees, text editor data structures and bringing Clojure-style persistent structures to C++.
HN commenters in memory management and language design threads cite it as the best explanation of group lifetimes versus per-object ownership.
HN treats it as the classic go-to for learning atomics and memory ordering, recommended over books.
HN recommends it as an entertaining talk that starts simple and goes deep on practical performance optimization.
A favorite on Ask HN lists of programming YouTube channels, praised for mind-blowing systems and graphics programming and a watchable coding style.
HN recommends it as an entertaining, mind-blowing look at compiler cleverness from a great speaker.
HN returns to it to explain why Go deliberately resists syntactic sugar and new features.
Recommended whenever versioning, semver, monorepos and backward compatibility are debated, for its nuanced treatment of dependencies.
HN considers it one of the best talks for understanding how containers work from the ground up.
Recommended as a fast, brilliant introduction to GDB's TUI mode and lesser-known features, useful for anyone who has only used IDE debuggers.
HN recommends it as the main introduction to Cpp2 and cppfront, and as a credible effort to evolve C++.
HN repeatedly points people to it as the best overview of low-latency trading engineering.
HN points to it as the founders' own explanation of what Oxide is building and why, a frequent link whenever Oxide comes up.
Cited again and again as the framework for discussing languages in terms of values, and how organizational values shape software quality.
Frequently linked as an entertaining and alarming account of OpenSSL code quality and why the fork happened.
HN commenters bring it up whenever C++ complexity or the pitfalls of language design come up, as a witty and authoritative warning.
HN programmers admire it as a clean, clever demonstration of emulator design and as the standout of a favorite programming YouTuber.
HN recommends it as an accessible way to remove the magic from Docker and understand how containers work.
HN cites it as one of the best talks on data-oriented design, applying struct-of-arrays and compact data layouts to a real compiler.
HN cites it in C++ versus Rust safety debates for its lifetime profile demo, and recommends it as a modern C++ talk.
HN recommends it as an approachable way into C and low-level programming that gets to something visible quickly.
HN cites it in memory management debates for its treatment of reference counting problems, destructor stack overflows and deferred pointers.
Commenters repeatedly point to it as an astonishing, beautiful piece of obfuscated-C code golf.
Pointed to as the in-depth talk on exception mechanics and code size for embedded C++.
HN points to it to show how deliberately the Rust team arrived at async/await and why it was chosen over alternatives like green threads.
HN recommends it as a must-watch catalogue of C++ footguns, often cited in debates about Rust and C++ safety.
The standard link for explaining the concurrency versus parallelism distinction and the motivations behind Go's concurrency model.
Recommended during the await syntax debates for explaining the constraints that shaped Rust's async design.
HN people point to it as a rare chance to watch skilled developers write real code live, pair programming and explaining as they go.
Pointed to whenever C++ exception overhead, bans on exceptions or error-handling alternatives come up.
Commenters rate the whole playlist as high-quality, clear teaching that builds foundations from memory and machine instructions up to different paradigms.
HN people share it as a striking demonstration of how much graphics a modern terminal can do.
HN returns to it as the go-to talk on string internals, small string packing and why small percentage optimizations matter at scale.
HN recommends it as a phenomenal talk on Zig's C interop and on choosing between C, Rust and Zig for systems work.
Commenters say it changes how you think about types and the STL, and makes a case for simple modern C++.
HN points to it whenever undefined behavior comes up, as the best explanation of the reasoning behind UB, though some dispute its framing.
Cited in Rust and systems-language threads as the best introduction to ATS, a language claimed to go beyond Rust's safety guarantees.
Recommended as the best presentation on how modern CPUs run code, and why speculative execution matters for performance.
HN calls it a surprisingly fun, approachable talk on a hard problem and cites it in floating-point threads.
Recommended in C versus C++ and embedded threads as the expert view on adoption and persuasion.
HN treats it as the definitive resource for understanding Pin semantics and lists it among async Rust learning materials.
HN recommends the series as a thorough look at low-level game programming by someone with deep knowledge, offered free.
HN points to it as the go-to explanation of why memory layout beats pointer-chasing structures on real hardware.
HN recommends it as an enlightening explanation of atomics, caches and memory ordering from a strong presenter.
HN recommends it as an exciting look at how a browser can be rebuilt for performance and safety, including the WebRender ideas that fed into Firefox Quantum.
Recommended as a fascinating technical account of the optimizations behind uv's speed.
HN recommends it as a detailed, entertaining look at the crazy optimizations compilers do.
HN recommends it as an eye-opening primer on benchmarking and performance analysis, especially for people who have not benchmarked on Linux.
Recommended whenever the STL mindset or avoiding raw loops in C++ comes up, as an enlightening talk on expressive algorithms.
HN people recommend it as the starting point for modern C++ and for the language's safety story.
HN recommends it as the clearest account of the CSP lineage behind Go's goroutines and channels.
Praised as the best talk of CppCon 2017 and the key introduction to metaclasses and generative C++.
It is the standard citation in HN arguments over Rust for game development, the borrow checker and ECS designs, as a skeptical view from an experienced game developer.
HN uses it as a concise statement of the thinking behind Go's design.
HN points to it for background on how the Go toolchain targets many architectures and why its assembler is designed that way.
HN recommends it as an in-depth, practical introduction to atomics and weak versus strong memory ordering, relevant to ARM and Rust as well as C++.
HN commenters recommend it in Smalltalk and Unix threads as a demonstration of runtime dynamism hiding in native binaries and shared libraries.
HN fans praise Bisqwit as a favorite programming YouTuber and this video as an excellent look at dithering.
HN recommends it as a good overview of modern C patterns, including in threads about learning C.
HN lists it among good resources on building text editors and as a recommended lunch-and-learn talk.
HN commenters recommend it as a demonstration of SerenityOS's hackability and fast iteration across all layers of the system.
HN commenters recommend it as the main resource on Swift as an incremental successor to C++ and on how the interoperability works in practice.
HN commenters recommend it as an introduction to real-time and low-latency programming in C++ for people getting into audio.
Recommended as a great talk on solving fragmentation for C/C++ and runtimes like Ruby and Python without code changes.
Used as the primary source for Apple's stated plan to make Swift its successor to C++ and for how interop supports gradual transition.
The go-to reference for why file operations are slow on Windows and how antivirus filters, not NTFS itself, are the cause.
Recommended as a slow-paced, detailed live-coding session that makes lifetimes click once you are past Rust basics.
Recommended as a quick, clear overview of allocators and arenas that also shows how Zig approaches allocation.
HN cites it as a concrete, worked example of data-oriented design and as an alternative to OOP in performance-sensitive code.
HN people point to it as an excellent, inspirational talk on Rust GUI architecture, and it led many to the Druid project.
Cited as the talk that introduced Upspin, and called fascinating and really good by commenters.
HN points to it as a fun, technically deep talk that makes memory-safety bugs vivid through a beloved game.
HN points to it as the best deep dive into Mojo's design, including MLIR use and SIMD-first scalars.
Recommended as a clear, practical introduction to atomics and lock-free programming in C++.
HN commenters point to it as a convincing primary-source interview showing Zig's cohesive design vision and the creator's level-headed reasoning.
HN commenters recommend it for the live-coded demos running at high frame rates, calling the performance impressive.
Recommended as a good watch on how Go's M:N:P scheduler works and why it was designed that way compared with alternative schemes.
Cited as evidence that large production apps share a C++ core with native UI, in cross-platform and React Native or Flutter debates.
Cited as evidence that DOM access is not the bottleneck for WebAssembly, and as an explanation of signals-based updates versus virtual DOM.
Frequently cited for the claim that Photoshop's codebase could shrink dramatically with generic programming.
HN uses it as the primary source for Microsoft's Rust adoption and its reasoning on TPM and security requirements.
HN repeatedly cites it for Midori lessons: compatibility matters for adoption, and the Windows team stayed sceptical even with Midori running real workloads.
Pointed to as a non-promotional, realistic long session of an experienced engineer working with AI on non-trivial code.
HN points to it as the authoritative talk on Swiss tables, their design rationale, and real-world effects like Hyrum's law.
Recommended as a thorough, well-regarded explanation of hash table design tradeoffs and why the standard container is a poor choice.
Cited in Electron, Flutter and React Native debates as evidence that large products can share C++ core code with native views.
Cited as a good talk on the thinking behind C++11 and on using the type system to prevent bugs; some other mentions quote it critically.
HN recommends it as the best calm explanation of unsafe Rust, from a speaker commenters trust on the topic.
HN commenters point to it in discussions of goto, early returns and cognitive load when reading code.
Recommended as a deep, practical dive for learning how Rust async works.
HN points to it in monorepo and refactoring discussions as a great account of large-scale changes at Google.
Recommended as a clear, from-scratch demonstration of how simple code hot-reloading is with plain OS facilities.
Pointed to in threads on defer, scope_exit and RAII as the clearest treatment of scope guards.
HN recommends Berger's talks as fascinating and cites Mesh as mind-blowing memory allocator work.
Pointed to as the authoritative source on Go's GC pause improvements, and later revisited when GC latency claims were challenged.
HN recommends it as a comprehensive walkthrough of the build-your-own-BitTorrent challenge and as an introduction to CodeCrafters.
Recommended as the source on how Compiler Explorer began and for its lesser-known features like the machine code analyzer.
Recommended for treating benchmarking and profiling scientifically rather than by myth, with innovative tools.
HN threads on Zig and Elixir link it as the creator's explanation of how Zig NIFs can behave nicely inside the BEAM.
HN cites it in threads on Linux desktop application distribution as a clear treatment of why binary compatibility and static linking are hard.
HN points to it as a detailed, captivating talk by the Noria author, including a good explanation of deduplicating data between maps using unsafe.
HN people list it among the go-to talks for learning or refreshing modern C++ style, and cite it for Sutter's guidance on function parameter passing.
HN recommends it as a careful, entertaining talk on low-level optimization that shows how textbook algorithms can be sped up.
HN points to it as a concrete demonstration of object-oriented versus cache-friendly design and the performance effects of branch misprediction.
HN treats it as the canonical source for Go proverbs, quoted in debates about dependencies, concurrency and simplicity.
HN points to it as the authoritative answer to why the team picked Go rather than C# or Rust, citing timestamps on cyclic data structures and garbage collection.
Which of these have you already seen?
Connect YouTube and HackerTube AI hides what you've watched and ranks the rest for you.