
Kernel Panic dives into Beating the compiler at integer division: why hand-written arithmetic tricks still outperform modern optimizing compilers.


technology
Hosted by Str8Digital · technology · EN-US
A show about software engineering, programming, architecture, debugging, developer tooling, and the realities of building and shipping software.
Required Pod Score for this podcast. PitchCentric checks your profile against host openness, topical fit, and audience signals before you generate a pitch.
Contact path
Verified email
Booking probability
33%
Guest openness
Selective
Sign up to generate a grounded pitch for Kernel Panic – Str8Digital.
Signup to Generate a PitchKernel Panic – Str8Digital is hosted by Str8Digital. The show has published 75 episodes to date.
Recent episodes include "Beating the compiler at integer division: why hand-written arithmetic tricks still outperform modern optimizing compilers" (2 November 2026, 26 minutes), "Rust for Linux at scale: which kernel subsystems have shipped production Rust drivers since stabilization" (30 October 2026, 25 minutes), and "Fuzzers vs AI: Google Project Zero compares Fuzzilli and BigSleep on JavaScript engines" (28 October 2026, 27 minutes).
Kernel Panic – Str8Digital publishes roughly a few times a week, with episodes averaging 24 minutes across 75 episodes.
Booking probability for Kernel Panic – Str8Digital is 33%, and the host is rated Selective on guests. Kernel Panic – Str8Digital requires a Pod Score of 80 or higher. Kernel Panic – Str8Digital's contact route on record: verified email.
The strongest fits for Kernel Panic – Str8Digital are IT Services & Software Development. Kernel Panic – Str8Digital has a technology audience.
Str8Digital hosts Kernel Panic – Str8Digital, a technology podcast with 75 episodes published.
Our AI reads these to draft pitches. Use them as grounding for a pitch that cites a real guest and a specific topic.

Kernel Panic dives into Beating the compiler at integer division: why hand-written arithmetic tricks still outperform modern optimizing compilers.

Kernel Panic dives into Rust for Linux at scale: which kernel subsystems have shipped production Rust drivers since stabilization.

Kernel Panic dives into Fuzzers vs AI: Google Project Zero compares Fuzzilli and BigSleep on JavaScript engines.

Kernel Panic dives into The C23 standard lands: what _BitInt, improved stdatomic.h, and new constraints mean for systems programming.

Kernel Panic dives into Nix for script dependencies: reproducible development environments without Docker.

Kernel Panic dives into AI-assisted kbuild speedup in Linux 7.4: Lorenzo Stoakes' 22-patch series that cut kernel compile times.

Episode #73
Kernel Panic dives into GitHub rewrites Git storage to replace Spokes: building infrastructure for agent-scale development.

Kernel Panic dives into Linus Torvalds' first LLM-assisted kernel patch series: what it reveals about AI in systems programming.

Episode #71
Kernel Panic dives into Landlock LSM: Linux kernel's new sandboxing primitive for unprivileged process confinement.

Kernel Panic dives into Go generics in production: what 4 years of real-world adoption taught us.

Kernel Panic dives into WebAssembly component model goes stable: what it means for polyglot microservices.

Kernel Panic dives into Rust's new async runtime landscape: comparing Tokio, async-std, and the emerging smol ecosystem in 2026.

Kernel Panic dives into Uber's ServiceScale controller: separating scaling intent from execution on Kubernetes.

Kernel Panic dives into Rust's Async Runtime Wars: tokio vs async-std vs the new contenders in 2026.

Kernel Panic dives into Node.js 24 LTS and what changes for production deployments.

Kernel Panic dives into Rust 2024 edition stabilization and what it means for the ecosystem.

Kernel Panic dives into Node.js 24 what changed and breaking changes to watch for.

Kernel Panic dives into Rust 2024 edition migration: what changed and how to upgrade your crates.

Kernel Panic dives into Swift 6.1 strict concurrency and the end of Sendable warnings.

Kernel Panic dives into Rust 1.80 and the new async trait stabilization.
PitchCentric classifies Kernel Panic – Str8Digital under these industries. Guests from them are the closest fit, and each links to the best podcasts in that industry.
Shows with the most semantically similar episode content. Pitch one, pitch all; producers cluster.
Is this podcast yours and you'd like to remove or correct details? Request removal or email privacy@pitchcentric.com.
Questions about the free trial? See the pricing FAQ