The catalogue
Every talk on DevTalks, 1480 of them, about 1109 hours in all. The channels are selections out of this list; this is the list. For a shorter one, there arethe best talks, each with a line on why.
None of these talks are ours and none of them are hosted here — each one links to the conference's own upload on YouTube. What is ours is which ones are here: a script proposes and a person approves, and nothing reaches a channel because a model thought it should.
English — 1319 talks
- What the heck is the event loop anyway?
- Practical (a.k.a. Actually Useful) Architecture
- What We Learned Dissecting the World's Most Popular Containers
- Simple Made Easy
- What nobody tells you about documentation
- Turning the database inside out with Apache Samza
- Microservices
- The Early Days of id Software: Programming Principles
- Outperforming Imperative with Pure Functional Languages
- Microservices, Where Did It All Go Wrong
- The Mess We're In
- Stop Writing Dead Programs
- Building Evolutionary Architectures
- Timeless Design Principles
- Java’s Evolution: What’s Coming in Java 22?
- Reacting to the Future of Application Architecture
- Making Hard Things Easy
- How to Build a Meaningful Career
- Comedy Writing With Small Generative Models
- The Economics of Programming Languages
- Playable Quotes for Game Boy Games
- New algorithms for collaborative text editing
- The Attacker Has Expensive Radio Equipment, But Your Android Phone Is Resilient
- IPVM: Seamless Services for an Open World
- Lessons from building GitHub code search
- Designing Dope Distributed Systems for Outer Space with High-Fidelity Simulation
- Building Koi Pond: Simulating Millions of Slack Clients
- Turning GraalVM from Research to Product
- Babashka: a meta-circular Clojure interpreter for the command line
- Didn't Chrome Already Have a Root Store?
- Building Strong and Sustainable Open Source Projects
- Human Involvement Behind Remote Desktop Protocol Brute-Force Attacks
- Can a Programming Language Reason About Systems?
- Designing Fully Rationalized Commercial Buildings with Generative Software
- Risks and Opportunities of AI in Incident Management
- Without Open Data, there is no Ethical Machine Learning
- Astronaut Horse: Stable Diffusion Artist Collaborations
- Unmasking the Godfather - Reverse Engineering the Latest Android Banking Trojan
- Ectype - bringing type safety (and more!) to vanilla JavaScript
- Why Programming Languages Matter
- Programming Distributed Systems
- Concatenative programming and stack-based languages
- Inside the Wizard Research Engine
- Formal semantics for multi-language programs
- Experimentation: putting research papers into prod
- War Time Proofs and Futuristic Programs
- An approach to computing and sustainability inspired from permaculture
- A JVM threading model for the containerized times
- Is my Large Language Model a Strange Loop?
- Computational Physics, Beyond the Glass
- Supporting Data Journalism through Compilers for Visual Inputs
- Swift as C++ Successor in FoundationDB
- Oatmeal is Cheap: A Fundamental Theorem for Procedural Generators
- Using data-driven metrics to anticipate and prevent security incidents
- Cursorless: A spoken language for editing code
- Software & The Game of Go
- Birdsong as code
- The Lemniscate
- Platform Engineering for Developers, Architects & the Rest of Us
- The Platform Engineer's Handbook
- Platforms: Build Abstractions, not Illusions
- State of the Art of Platform Engineering
- Platform Engineering Practices for Speedy Delivery
- The Future of Microprocessors
- Advanced Rust Programming Techniques
- The Past, Present & Future of Programming Languages
- Using Generative AI to Strengthen & Accelerate Learning
- Insights on How Team Topologies Drive Organizational Success
- Communicating in Types
- The C4 Model – Misconceptions, Misuses & Mistakes
- Panel Discussion: Where Is Software Development Going?
- Tidy First? A Daily Exercise in Empirical Design
- What's up with Rust?
- Add Useful AI to Your Web App (Not Just Chatbots)
- A Decision Maker's Guide to Typed Functional Languages
- Functional Programming in 40 Minutes
- A Code Centric Journey Into the Gleam Language
- 97 Things Every Java Programmer Should Know
- Elm & Open Source: What's Next?
- Solving the Hard Problems
- Early Days of Agile Development & Is Design Dead?
- AI-Powered Software Development From the Trenches
- Software Architecture, Design Thinking & Knowledge Flow
- I Don't Need Another Scrum Master, Get Me a Technical Coach!
- The Best Programmer I Know
- 3 Ways You're Screwing up Platform Engineering – And How to Fix It
- Panel: Microservices, Where Did It All Go Wrong
- Architecture Isn’t Kubernetes
- Exploring the Unintended Consequences of Automation in Software
- Platform Engineering: A Deep Dive Conversation
- Some Principles From Real World Internal Developer Platform Engineering
- The Magic of Small Things - 10 Years of Microservices
- Hedy: Creating a Programming Language for Everyone
- 20+ Years in Tech: Things We Wish We Knew Sooner
- Data: The Land DevOps Forgot
- The Efficiency Paradox: How to Save Yourself & the World
- Incremental Design, DevOps, Microservices & CICD
- Developer Productivity With IntelliJ IDEA
- Inside GPT – The Maths Behind the Magic
- Building Performant RAG Applications for Production
- Moldable Development: Programming Through Custom Tools
- How to Get People Excited about Functional Programming
- Adaptive Socio-Technical Systems with Architecture for Flow
- Building Secure ReactJS Apps: Mastering Advanced Security Techniques
- Dynamic & Proud
- AI Assistance for Software Teams: The State of Play
- Concerto for Java & AI – Building Production-Ready LLM Applications
- Architecture & Responsible Technology
- To the Moon
- The Technical Journey to Define the True Value of a Football Goal
- The Marvelous Magic of Multimodal AI
- Encrypted Computation: What if Decryption Wasn’t Needed?
- Moldable Development & Glamorous Toolkit in Practice
- Medieval strategies for Cyber Security
- Clean Code vs. Creativity
- Scalable by Design: How to Build an Elastic Cloud Infrastructure...
- A data innovation playbook
- Harnessing the Power of Materialised Views in Cosmos DB
- Proactive Defense: Leveraging Hacker Tools for Early Vulnerability Detection
- Enhancing the Performance of Engineering Teams
- Why have we not fixed all the vulnerabilities yet? Different perspectives...
- The Rise of the Tech Lead: Redefining Leadership in the Tech Industry
- Testing Library: everybody uses it, but nobody understands it
- Why you fail at Application Security - and how to fix it
- Enhance Developer Experience by community
- Kotlin Meta Programming - Code Generation with Kotlin Poet
- The browser kicked me out (of the CPU): Making a three.js WebGL mobile game
- Burning the playbooks: fireside chat with DHH
- 009 agents or how to empower people with security topic.
- Composability: The New Architect in Town
- How to implement DDoS protection in GCP
- Data Mesh and Supply Chain: How Data Mesh has improved HelloFresh's Supply Chain
- Data for Climate Action: Leveraging Data Science and Engineering
- Organizational Change Through The Power Of Why - SecDevOps Enablement
- How to build continuous security and embed it in your product
- The Evolution of UI/UX Design: Exploring Latest Trends and the Impact of AI
- Our journey from Gitflow to Trunk Based Development
- Escaping the Phantom Zone of Insecure Data: Build Safer Applications with zod
- Making pretty things with code: Getting started as Technical Artist
- Growing the PHP Core – One Test at a Time
- Batching Was Yesterday: Real-Time Tracking & Analysis For 100+ Million Visitors
- Cyberattacks easily implemented with AI?
- Embracing resiliency in GraphQL - Drop the cache-aside pattern and overcome the...
- Unlocking the Power of Integer Programming: Beginner's Guide to Conference Scheduling
- Values in Tech - Just a Buzzword or an Action-Item?
- 3 reasons why micro-services aren't the miracle cure
- How to (not) f**k up any organisation with your CMS
- Speeding Up Your Angular App: Techniques for Optimizing Rendering Performance
- Programming Is the Easy Part
- How to talk like an Engineer
- Busy TypeScript Developer's Guide to Advanced TypeScript
- Speed up your Web Application
- Jira to GitHub Issues: Convincing Your Product Owners to Make the Switch
- Lifting Large Language Models on Kubernetes
- Event Streaming and the Future of Applications
- Greenhouse Gas Emission Data: Public, difficult to access, and not always correct
- How to keep Open Source open without leaving our communities open to threats
- BE Modded: Exploring and hacking the Vital Bracelet ecosystem
- The Angry Path to Zen: AMD Zen Microcode Tools and Insights
- What Makes Bike-Sharing Work? Insights from 43 Million Kilometers of European Cycling Data
- When 8 Bits is Overkill: Making Blinkenlights with a 1-bit CPU
- Watch Your Kids: Inside a Children's Smartwatch
- A Quick Stop at the HostileShop
- The Small Packet of Bits That Can Save (or Destabilize) a City
- Design for 3D-Printing
- Cracking open what makes Apple's Low-Latency WiFi so fast
- In-house electronics manufacturing from scratch: How hard can it be?
- Asahi Linux - Porting Linux to Apple Silicon
- Chaos Communication Chemistry: DNA security systems based on molecular randomness
- Reverse engineering the Pixel TitanM2 firmware
- Agentic ProbLLMs: Exploiting AI Computer-Use and Coding Agents
- When Vibe Scammers Met Vibe Hackers: Pwning PhaaS with Their Own Weapons
- Pixel Bureaucracy At The Scale Of Chaos - or: Torturing 286 People By Pretending To Be The Government
- WAF: Wrong Approach Firewall
- Popping podman/dockers bonnet: Unraveling the image pull process while developing for Forgejo
- MMO-CHIP: From Microscope to Verilog in an hour
- Building video games with 20 year old tech
- Three Languages, Triple the Confusion
- introducing pgreflex - an open source convex alternative for postgres
- Breaking architecture barriers: Running x86 games and apps on ARM
- From Idea to JEP: An OpenJDK Developer's Journey to Improve Profiling
- Gaslight, Gatekeep, Girlboss: Breaking Minecraft's Decentralised Chat Reporting System
- KeepKarlsruheBoring: collective agendas, boredom and maintenance
- User-Centric Product Management in Open Source
- Porting the TypeScript Compiler to Go for a 10x Speedup
- Goroutines and Cells: Lessons in Goal-Directed Systems
- AI and Go: Opportunities and Challenges Panel Discussion
- Go Faster: Integrating CUDA in Go for GPU Acceleration
- Strategies for Auto-Instrumenting Go Applications Without Code Changes
- The Code You Reviewed is Not the Code You Built
- Go Plays Nice With Your Computer - Race Detection and Freedom!
- Understanding Escape Analysis to Speed Up Your Code
- LLM Agents in Production: Why Go is the Missing Piece
- Scaling LLMs with Go: Prod Patterns for Handling Millions of AI Requests
- Plowing Through Data: Building Flexible Pipelines with Go
- Profiling Request Latency with Critical Path Analysis
- My Protobuf Module is Faster than Yours (Because I Cheated)
- Building a Decentralized Social Media App with Go and ATProto
- Go's Trace Tooling and Concurrency
- Next-Gen AI Tooling with MCP Servers in Go
- Analysis and Transformation Tools for Go Codebase Modernization
- An Operating System in Go
- Go's Next Frontier
- The Go Cryptography State of the Union
- Advancing Go Garbage Collection with Green Tea
- Through the Fire and the Flames
- Build bigger in less time: code testing beyond the basics
- A gentle introduction to procedural macros
- Practical Rust for Web Audio
- Augmented docs: a love letter to rustdoc and docs.rs
- The Impact of Memory Allocators on Performance: A Deep Dive
- Proving macro expansion with expandable
- Runtime Scripting for Rust Applications
- Unleashing The Ferris Within
- The first six years in the development of Polonius
- Non-binary Rust: Between Safe and Unsafe
- Writing a SD Card driver in Rust
- My Journey from WebDev to Medical Visualization Rustacean
- Code to contract to code: making ironclad APIs
- Rust Irgendwie, Irgendwo, Irgendwann
- Linting with Dylint
- Renaissance of Terminal User Interfaces with Rust
- Windows Kernel Programming with Rust
- Fast and efficient network protocols in Rust
- I/O in Rust: the whole story
- Generating ergonomic C++ APIs using Rustdoc, procedural macros, and Serde
- Building an extremely fast Python package manager, in Rust
- Powerful Macros, Good IDE Support, No Headaches. Choose Two
- Extending Rust's Effect System
- Implementing a Blazingly Fast Quantum State Simulator in Rust
- Fine! I'll just make my own stable ABI!
- Profiling async applications in Rust
- Beyond Ctrl-C: the dark corners of Unix signal handling
- A Rust-based garbage collector for Python
- GUI Accessibility Across Platforms and Programming Languages Using Rust
- Rust Foundation: Demystified
- Async building blocks: A streaming Data Drama in Three Acts
- Rewrite it in Objective-C?
- Integrating Rust and Go: Lessons from Github Code Search
- Anything you can do, I can do worse with macro_rules!
- How Powerful is Const
- Infrastructure for Rust
- Using Rust and Battlesnake to never stop learning
- Rust in the Wild: A Factory Control System from Scratch
- Rustacean Community Interfaces: A Tale of Many Hats
- Rusty Genomics: Rust in the Biosciences
- The Art and Science of Teaching Rust
- The standard library is special. Let's change that.
- Too many cooks or not enough kitchens?
- Rust in the skies over Antarctica
- Designing Components for Fun, Profit and Sanity
- The Browser as a Modular, Networked Video Synthesizer
- Real World Problems - Internet beyond the 1st World Bubble
- State Machines Meet React Hooks
- Getting Closure on React Hooks: Can Swyx recreate React Hooks and useState in under 30 min?
- Vue.js: Seeking the Balance in Framework Design
- Learning From Machines
- Double the Beyoncé: Navigating Numbers in JavaScript
- Race Conditions in JavaScript Apps
- The Different Transformation Stages of AOT Compilers
- Pair Programming & Test Driven Development done right
- Composing music with composed functions
- TDCD: Test Driven Component Development
- Make it Boring
- The (Full)stack Trace: Understand Your App with Distributed Tracing
- A11Y IRL (Accessibility in real life)
- Tour de Bikeshare: Setting World Records with JavaScript
- Trans Eye for the Cis Ally: Ensuring an Inclusive Community
- Componentizing end-to-end tests
- Meet the Packets: How audio travels into your browser
- Advancing Focus
- ¿Donde Esta La BiblioTech?
- Decoupling Applications from Architectures
- Creating Beautiful LED Art with JavaScript
- Staying confident without feeling like an imposter
- Just go for it: The story of dance-mat.js
- Empathy is not enough - the power of engaging hard-to-reach users
- Building Open Source Communities
- CSS Algorithms
- Components as Data: A Cross Platform GraphQL Component API
- Keynote: Cory Doctorow
- Keynote: Lynn Root
- 503 days working full-time on FOSS: lessons learned
- Or Else! An Exploration of Obscure Control Flow
- Why `len('😶🌫️') == 4` and other weird things you should know about strings in Python
- Phantom Dependencies: is your requirements.txt haunted?
- Cython in Practice: A Deep Dive into Legacy C Integration and Debugging
- Inclusive Data for 1.3 Billion: Designing Accessible Visualizations
- NLP para la preservación del lenguaje indígena Quechua
- Elastic Generics: Flexible Static Typing with TypeVarTuple and Unpack
- Intuition vs. Reality: Surprising Truths in Python Performance
- When GPUs Make Python Slower: Patterns and Pitfalls
- Writing Extension Modules To Be Interruptible
- Reduce the environmental footprint of your Python programs
- Unlocking Python's Power: A Practical Guide to Metaprogramming with Decorators, Metaclasses, and Dynamic Code Generation
- Más allá de Try-Except: La frontera de Python en el manejo de errores con Monadas y Railway Magic
- Transformando Gafas en Asistentes Inteligentes: Open Source Vision Language Models
- Going From Notebooks to Scalable Systems
- Bridging Python and Apache Iceberg™: The Power of PyIceberg
- Programming for Yourself
- Cómo llevar tus presentaciones técnicas al siguiente nivel con Python + Quarto
- Notes, Groups and Stars: exceptional new features of Python 3.11!
- The Zen of Polymorphism: Choosing between isinstance(), methods, and @singledispatch
- Selenium with Python using Robot Framework
- Django Asíncrono: Desbloqueando el Poder de la Programación Async
- Unlearning SQL
- Make Python Talk, Make Python Listen
- The Most Bizarre Software Bugs in History
- Diseñando y Construyendo Teclados Personalizados con Python
- Scale Smarter, Not Harder, with cuPyNumeric
- World's First Undoable Notebook
- The PyArrow revolution in Pandas
- Working with Audio in Python (feat. Pedalboard)
- Beautiful and Balanced: Using Color Theory in Data Visualization
- This Talk Has Been Disabled
- Zoom, Enhance: Asyncio's New Introspection Powers
- What they don't tell you about building a JIT compiler for CPython
- Iterando de forma eficiente en Python con Itertools
- The invisible thread: Scaling under regulation and geopolitical risk
- Never Trust a Monkey! Can We Trust AI-Generated Code?
- Java 25 in Production: Memory Dieting to Tame Latency and Garbage Collection
- Learning modern Java the playful way
- Integrating AI into Your Java Applications: Spring AI Deep Dive with RAG
- Make Cybersecurity Fun: Host Your Own Security-Themed Hackathon
- Solving grid congestion in 15 minutes
- Securing the Open Source Supply Chain
- AI at Every Step: Why Are You Still Doing the Dev Cycle by Hand?
- Building a legacy: The art of crafting maintainable systems
- Language Games
- Avoiding pitfalls with Java streams, concurrency, HTTP requests and more
- How to trace a Java Memory Leak
- 10 Things I Hate About Java
- Possessed by Packages: Is Your JavaScript Haunted?
- Six and a half ridiculous things to do with Quarkus
- Commit to Change: From Analyst to Java Developer
- GraalVM 25: What's New and What's Next
- Stop Guessing, Start Trusting: The Power of Contract Testing
- Engineering a Better Java Build Tool
- Write Java Code Like a Seasoned Hacker: 2026 Edition
- Early returns from outer space (in Kotlin)
- 10 Million Spans Per Second: Lessons From Scaling OpenTelemetry at Reddit
- Tracing the Agent's Mind: Extending OpenTelemetry for Deep MCP Inspection
- Let Them Eat Bugs: Practical Showcase of Agentic Issue Resolution
- The Legend of Config: Breath of the Cluster
- Breaking Free from Vendor Lock-In: Nubank DIY Observability Success
- eBPF Application Instrumentation for Java: Challenges, Design, and Real-World Examples
- Applying Observability to the Internet of Living Things (IoLT)
- Observing the Observers: Bringing OpenTelemetry to Autonomous AI Agents
- Devs, Transform (Your Data) and Roll Out!: Learning and Leveraging OTTL
- How Observability-First Development Lets You Ship Agents in Weeks, Not Months
- Implementation of Unified Observability at Scale From Scratch
- One Size Does Not Fit All: A Polystore Architecture for Logs and Traces
- Beyond Dashboards: Architecting AI Agents for Autonomous Observability
- How not to use OAuth
- Tuomas Artman - Building a synchronous experience with asynchronous data: Linear's sync engine
- A semiautomatic approach for testing the accessibility of web pages
- The Developer's Guide to FLOSS Licenses
- Man against Compiler
- GDPR and ePrivacy: Compliance Nightmares for Open-Source Projects?
- Automated lung tumor diagnosis in medical image data - methods, challenges and perspectives
- AI and the End of the World
- Performance Analysis in the Cloud
- Let's talk about Desktop Linux Platform Issues
- Blessed by the algorithm
- 12 years as QA in Agile Teams - what has worked and what hasn't
- Beyond WHERE and GROUP BY
- The Apache Way! ... ?
- From linear algebra to machine learning
- InnerSource: Open Source collaboration patterns beyond public FOSS projects
- Assertions considered Harmful
- Generic Graphics Tablets in Linux
- Let's roll out mass encryption!
- The Computer Science behind a modern distributed data store
- Exploring Sculpt a component-based operating system
- The spectre of hardware bugs
- Internet of Things – novelty and comfort vs. security
- Cyborgs Unite!
- System-Level Transactions with picotm
- Handling Billions Of Edges in a Graph Database
- It's all about the goto
- IoT ethics
- Storing Non-Scalar Data
- Teaching machines new tricks
- 8 Years of Config Management
- Linux kernel debugging for sysadmins
- Cost-Efficient Virtual Petabytes Storage Pools
- Bazel
- Flow-Based Programming for JavaScript
- The little bot that wasn't
- Microservice Toolbox
- The Forest & The Desert Are Parallel Universes
- The C4 Model: Visualizing Software Architecture
- Cloud, Containers, Security & AI - What's Now, What's Next?
- Signals & Levers
- The Architect's Guide to the AI Era
- Model-Based Systems Eng. & Requirements Definition
- Sovereign Cloud: Who Really Owns Your Infrastructure?
- Dungeons, Dragons & Developers
- Continuous Delivery in a World of Constant Change
- Go for Java Programmers
- Engineering Leadership in Turbulent Times
- Modern Concurrency in Java
- Roc & Zig: A Compiler Rewrite Story
- Tech Truth: Agile Evolution & the Future of SW Engineering
- Spec-Driven Dev Is Back. But Not How You Think
- State of the Art of Java in 2026
- Kafka for Architects
- Tech Truth: Teaching Kids to Code with Sonic Pi
- Toad: Your AI Coding Agent Deserves a Better User Interface
- Java Cookbook
- The Typo That Broke Production — And Accidentally Created Spring Cloud Contract
- Learning API Styles
- A Common-Sense Guide to AI Engineering
- Beyond the Hype: What AI Actually Can (and Can't) Do
- Kubernetes at the Edge
- Every Software Org is Dysfunctional
- Software Security for Developers
- Learn Docker in a Month of Lunches
- One Size Fits None: How Platform Engineering Must Evolve
- How To Build a GenAI-Augmented Software Organization
- Platform Engineering
- State of the Art of Container Security
- The Rush to Adopt AI: How to Get it Right & Business Risks
- Learn C++ by Example
- State of the Art of Biological Computing
- Architecture for Flow
- Security & Developer Experience: Can We Have Both?
- The Lean Tech Manifesto
- Building Planetary-Scale Data Systems with Venice
- SW Design, Architecture & Clarity at Scale
- Effect Oriented Programming
- Spring Then & Now: What's Next?
- Serverless Panel
- Clean Architecture with Python
- Handling AI-Generated Code: Challenges & Best Practices
- CI/CD Evolution: From Pipelines to AI-Powered DevOps
- Quarkus in Action
- State of the Art of DORA Metrics & AI Integration
- Modern Full-Stack Web Development with ASP.NET Core
- This AI Fights Health Insurance Denials
- Building Modern Databases with the FDAP Stack
- Modern X86 Assembly Language Programming
- The AI Engineer's Guide to Surviving the EU AI Act
- Java Generics and Collections
- Building Better Software: Why Workflows Beat Code Every Time
- Building Software That Survives: Autonomy, Architecture & Alignment at Scale
- Fundamentals of DevOps & Software Delivery
- Learning Python Programming
- ASP.NET Core 9 Essentials
- Why Software Architecture is Mostly Communication
- Fundamentals of Data Engineering
- The Death of Classical Computer Science
- C++ Memory Management
- The End of Engineering's Blank Check: Accountability in SW Leadership
- Reliability Engineering Mindset
- How to Discover the Binary System as a Child
- Breaking the Architecture Bottleneck
- Beyond the Hype: Real Talk on AI-Assisted Development
- From Hardware Hacker to CTO: Building Teams That Scale
- Real-World Java
- The Debugging Book
- Domain-Driven Refactoring
- Building Support Structures
- Platform Engineering: From Theory to Practice
- Infrastructure as Code
- Tech Leadership Challenges: Communication & AI at Financial Times
- Simplicity
- Writing for Developers
- The Blind Spots of Platform Engineering
- Serverless Apps on Cloudflare
- Building a Debugger
- Flow Engineering
- Ethics in AI: Biases & Responsibilities
- Effective Code Reviews with Conventional Comments
- Beyond the Cloud: The Local-First Software Revolution
- Professional Skills for Software Engineers
- TypeScript Cookbook
- "Residues" & "The Architect's Paradox"
- Building Bridges: From Developer to Developer Advocate
- Balancing Coupling in Software Design
- Can You Change the Behavior of a Running Node.js Process From the Outside?
- Testing in Production
- The Micro-Frontend Revolution at Amex
- From 1 to 101 Lambda Functions in Production: Evolving a Serverless Architecture
- Demystifying Memory Leaks in JavaScript
- Safely Handling Dynamic Data with TypeScript
- Logging, Metrics, and Tracing with Node.js
- Don't Try This at Home: Synchronous I/O in Node.js
- Work-Life Balance, Surviving a Company Merge
- Java on Mobile - JavaFX
- Project Leyden, Babylon, Panama - TornadoVM
- Inspiring the Next Generations
- Maven 4, AI Impact and Calculations, Graph Databases
- AI Tools for Developers
- Quarkus Unleashed
- Architecture as Code: Quantifying Architectural Trade offs
- How browsers REALLY load Web pages
- The Future of Refactoring: Test Driven Navigation
- Not just code: Abusing Claude Code to do just about anything but coding
- Finally, final means final: A deep dive into field immutability in Java
- Spring Boot: Chapter 4
- Live Coding The Hive: building a microservices ready modular monolith
- Virtual Threads, Structured Concurrency and Scoped Values: Putting it all together
- Your Code Base as a Crime Scene
- Level Up Your LangChain4j Apps for Production
- Local Development in the AI Era
- From the comfort of AWS to the unknown of GCP and Back?!
- Behavioral Software Engineering
- Robotics and GraalVM native libraries
- A Developer's Search for Meaning: Thriving as AI Transforms Our World
- Backlog.md : Reaching 95% Task success rate with AI Agents
- Accelerating Maven Builds: From Snail's Pace 🐌 to Rocket Speed 🚀
- Unleashing Vector Search with Spring AI, LangChain4J, Hibernate Vector, and the Oracle Database 23ai
- Bootiful GraalVM
- Java for AI
- The Awareness Layer
- Agentic AI Patterns
- Supercharge your JVM performance with Project Leyden and Spring Boot
- It only starts with a container
- Augmented Development, the successes, surprises and pitfalls
- Enable Digital sovereignty by tech stack liquidity
- GraalVM meets WebAssembly
- ONNX Based Generative AI LLMs in Java with Project Babylon
- The New AI Native Dev Coding Workflow
- When auto scaling isn't fast enough: Handling high volume live event traffic
- Discover the Agent Development Kit for Java for building AI agents
- The Bold, the Broken, and the Burned: Hard won lessons in the 6 years of developing Quarkus
- Coding, Rewritten: What 10.000+ AI-Generated Code Completions Taught Me About the Future of Software
- Ask the architects
- Unifying AI integration with Model Context Protocol
- The Diabolical Developer: Rise of the Rogue Agents
- Pattern Matching, Under the Microscope
- Building AI agents with Structured Outputs, Function Calling, and MCP
- Securing MCP Servers
- Beyond local tools: Deep dive into MCP
- There may not be intelligent life in our Universe after all
- How package encapsulation with Spring Modulith simplified our code
- Passkeys, one time tokens: passwordless Spring Security
- What Can You Do with an Apache Kafka "Queue?"
- Delay the AI Overlords: How OAuth and OpenFGA Can Keep Your AI Agents from Going Rogue
- Code Review Remarks: Lessons Learned
- It's Fine Actually: Doing Better in Legacy Java
- MCP in Action: Connecting AI to Enterprise Systems
- Crypto Agility: Prepare for the unexpected!
- Legal JVM dopes for your apps
- Application Architecture for Real World Continuous Delivery
- Spec Driven Development: Why your prompt chaos won't scale
- Serialization 2.0: A Marshalling Update!
- TDD & DDD From the Ground Up Live Coding
- The Best of Java Shorts Show: 100 Snippets in 50 Minutes
- Structured Concurrency in Action
- Why I Am Not Afraid AI Will Take My Job
- Hacking your parenting
- Things You Thought You Didn't Need To Care About That Have a Big Impact On Your Job
- What's new in Spring Modulith?
- Enterprise Architecture = Architecting the Enterprise?
- Minimum Viable Architecture
- Large-Scale Architecture: The Unreasonable Effectiveness of Simplicity
- Migrations - The Hardest Actual Problem in Computer Science
- Event Sourcing
- Don't Trust Anything! Real-world Uses For WebAssembly
- Understanding Rust – Or How to Stop Worrying & Love the Borrow-Checker
- The Beauty of Simplicity - Making Your Own Technology
- The Lost Art of Software Design
- The Art of Code
- So You Want To Be A CTO
- What Comes After Microservices?
- Enterprise Integration Patterns 2
- Visualizing Performance - The Developers' Guide to Flame Graphs
- Test Driven Development (TDD): That's Not What We Meant
- When to Choose Rust
- Livebook & Elixir: Where AI, Web & Concurrency Meet
- Simplifying Systems with Elixir
- Intro to Functional Programming in Rust
- Idioms for Building Fault-tolerant Applications with Elixir
- Software Architecture for Developers
- Side-Effects Are The Complexity Iceberg
- Personalities at Work
- Analogue Evolution, Digital Revolution: Tipping Points in Technology
- Confessions of an Enterprise Architect
- Building Your Own Compiler the Slightly Easier Way With LLVM
- BEAM Concurrency in Action
- OCaml for Fun & Profit: An Experience Report
- Infrastructure As Code
- One Rule to Rule Them All
- How to Improve Developer Productivity
- 3X Explore, Expand, Extract
- Event Modeling from Beginner to Expert
- A Taste of Type Theory
- Simple Functional Effects with Tag Unions
- Just-in-time Architecture
- Why Functional Programming Matters
- GitHub Copilot: Coding Will Never Be The Same Again
- Improving Software Flow
- Cloud Performance Root Cause Analysis at Netflix
- Unison: A Friendly Programming Language from the Future Part 1
- eBPF: Fueling New Flame Graphs & more
- Conversational x86 ASM: Learning to Appreciate Your Compiler
- There's No Such Thing As Plain Text
- MVP: Why We Confuse Building to Learn with Building to Earn
- The Best OO Language is a Functional One
- The Unicorn Project & The Five Ideals
- Sustainable Augmented Development
- Racket: A Programming-Language Programming Language
- C4 Models as Code
- Is Software Engineering Real Engineering?
- Event Modeling
- Beyond REST - Contract Testing in the Age of gRPC, Kafka & GraphQL
- Hot Deploying Low-Latency Services for 24/7 Operation
- Five Common Signs of a Dysfunctional Leadership Team
- Designing Distributed Systems with TLA+
- Typing Is Not The Bottleneck
- The Perfect Language
- A Day in the Life of a Netflix Engineer
- CUPID — For Joyful Coding
- Stories Every Developer Should Know
- Discontinuous Improvement
- Elixir's Ecto: Functional-Relational Data Access Done Right
- Architecture Challenges Faced by Agile Organisations
- Code Red: The Business Impact of Code Quality
- Designing for Failure: Scaling Uber by Breaking Everything
- Software Architecture, Team Topologies & Complexity Science
- Moldable Development with Glamorous Toolkit
- Building Evolutionary Architectures: Principles & Practices
- Applied Category Theory
- Infrastructure as Actual Code
- How Cognitive Biases Affect our Software Architectures
- Trust Deterministic Execution to Scale & Simplify Your Systems
- How to Read Complex Code
- Build Software Like a Bag of Marbles, Not a Castle of LEGO
- The Essence & Origins of Functional Reactive Programming
- Full-Stack Haskell: From Prototype to Production
- Architects Live in the First Derivative
- Getting Buy-In: Overcoming Larman's Law
- What You Need To Be A CTO
- High Performance Managed Languages
- Building Evolutionary Architectures
- Adaptive Architectures - Building API Layers that Build Themselves
- How to Lead Your Organisation's AI-Transformation
- Code Review-Review is the Manager's Job
- GitHub Copilot - How It Works, How We Got Here, Where It's Going
- How Metaflow Became Netflix's Beloved Data Science Framework
- How I CTO
- Programmer's Apprentice Season 2: Future Directions in AI-assisted Coding
- Considering Migrating a Monolith to Microservices?
- Java Renaissance
- Effective Programming in OCaml
- What Your Mother Never Told You About Agile Development
- A perfect match: Dapr & Azure Container Apps
- You Keep Using That Word: Asynchronous And Interprocess Comms
- Exploring Serverless Options for .NET in Azure, AWS, and Beyond
- An Infrastructure as Code Bake-off, comparing ARM, Terraform and Bicep
- Adding Live, Interactive Video to Your Application with Amazon IVS
- Running a real world, mission-critical system on Azure
- How Kubernetes optimisation can combat climate change
- Comprehensive testing strategies for modern microservice architectures
- IaC Forged in Code: ARM/Bicep vs Terraform vs Pulumi
- Becoming API- & Cloud-First at the LEGO Group
- Your code is just a detail
- How to Build a Quokkabot
- From Domain Boundaries to Software Architecture
- Alpaca Static Typing on the BEAM
- Lessons for the Masses from the Trenches of Co-dfns
- Breaking Down Programming Paradigms: APL's Surprising Learning Curve
- 50 Years of APL Datatypes: From Booleans to Hypercomplex Numbers
- Enough x86 Assembly to Be Dangerous
- The Functional Tao of Bash
- What is new in C and POSIX?
- Advanced C Coding For Fun!
- Evolving Clojure with Virtual Threads
- Making Tools Developers Actually Use
- fn and Games with Arcadia
- Solving Problems the Clojure Way
- Functional Programming in Anger
- Core.Async in Use
- Symbolic Assembly: Using Clojure to Meta-program Bytecode
- Bare Metal Clojure with clojure.Spec
- Clarifying Rules Engines with Clara Rules
- Clojure at DataStax: The Long Road From Python to Clojure
- Composing music with clojure.spec
- Creating DSLs: A tale of spec-tacular success and failure
- Live-Coding Mathematics: Your First Clojure Proof
- Managing One of the World's Largest Clojure Code Bases
- Parallel Programming, Fork Join, and Reducers
- Spec-ulation Keynote
- Using Clojure with C APIs for crypto and more
- Bottom Up vs Top Down Design in Clojure
- ClojureScript for Skeptics
- Condition Systems in an Exceptional Language
- Domain Specific Type Systems
- From REST to CQRS with Clojure, Kafka, & Datomic
- Game Development Development
- Genetic Programming in Clojure
- Hoplon and Javelin, WebDev Alternate Reality
- Purely Random
- Pattern Matching in Clojure
- Simplicity in Practice
- Solving Problems with Automata
- Specter: overcome your fear of nested Clojure data
- Always Be Composing
- ClojureScript: Lisp's Revenge
- How Clojure Works: Understanding the Clojure Runtime
- Making Games at Runtime with Clojure
- Predictably Fast Clojure
- Typed Clojure in Practice
- Variants are Not Unions
- Clojure: Enemy of the State
- Clojure in 10 Big Ideas
- Expert to Expert: Inside Clojure
- Jelly Stains: Thoughts on JavaScript, Lips & Play
- Build Your Own Lisp for Great Justice
- Playing Go with Clojure
- Predicate Dispatch
- The Macronomicon
- Embracing an Adversarial Mindset for C++ Security
- Peering Forward - C++'s Next Decade
- C++ Exceptions for Smaller Firmware
- Nano-coroutines to the Rescue! (Using Coroutines TS, of Course)
- Modern C++ in Embedded Systems
- -Os Matters
- 10 Core Guidelines You Need to Start Using Now
- Curiously Recurring C++ Bugs at Facebook
- Fantastic Algorithms and Where To Find Them
- Postmodern C++
- Rethinking Strings
- Rethinking Exceptions
- The Last Thing D Needs
- The Nightmare of Move Semantics for Trivial Classes
- Undefined Behavior in 2017 (Part 1 of 2)
- Undefined Behavior in 2017 (Part 2 of 2)
- Better Code
- Design Patterns in Modern C++
- Fastware
- Making C++ easier, faster, safer (part 2)
- STL Algorithms – How to Use Them and How to Write Your Own
- Thinking outside the synchronisation quadrant
- Better Code: Data Structures
- Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!
- Transducers: from Clojure to C++
- C++ on Mars: Incorporating C++ into Mars Rover Flight Software
- C++17: I See a Monad in Your Future
- Efficiency with Algorithms, Performance with Data Structures
- Lock-Free Programming (or, Juggling Razor Blades), Part I
- Lock-Free Programming (or, Juggling Razor Blades), Part II
- Making C++ Code Beautiful
- Optimization Tips - Mo' Hustle Mo' Problems
- Plain Threads are the GOTO of Today's Computing
- Pragmatic Type Erasure: Solving OOP Problems w/ Elegant Design Pattern
- Type Deduction and Why You Care
- Don't Help the Compiler
- Optimizing the Emergent Structures of C++
- Scaling with C++11
- Writing Quick Code in C++, Quickly
- C++11 Style
- Your CSS is a Mess
- Refactoring JIT Compilation
- SDC, a D Compiler as a Library
- The Soul of Erlang and Elixir
- GenStage and Flow
- Solid Ground
- Transforming Programming
- Build Your Own Elixir
- Dialyzer: Optimistic Type Checking for Erlang and Elixir
- Elixir in Elixir
- Explicit Elixir
- Learn Elixir: Building a Neural Network from Scratch
- Keynote: New Heights
- Securing Elixir Applications
- The Climb: Experiencing the Rise of Elixir from the Inside
- Keynote: Elixir Should Take Over the World
- Elixir: The Power of Erlang, the Joy of Ruby
- Demystifying Parsers
- If Coco Chanel Reviewed Elm
- The Life of a File
- Controlling Time and Space: understanding the many formulations of FRP
- Operable Erlang and Elixir
- Getting to the BEAM, without going through Erlang
- A Peek Inside Erlang's OTP
- Keynote: Distributed Jamming with Sonic Pi and Erlang
- Keynote: Pilgrim's Progress to the Promised Land
- Erlang: Evolution
- How To Ship New Code Without Taking Your System Down
- Implementing Languages on the BEAM
- OTP Has Done It
- Designing a Real Time Game Engine in Erlang
- Optimizing Native Code for Erlang
- Using Logic Programming Tools to Drive Property-based Testing
- Why The Cool Kids Don't Use Erlang
- Writing Quality Code in Erlang
- 26 years with Erlang or How I got my grey hairs
- Keynote: Over a Century of Programming
- Erlang in production: "I wish I'd known that when I started"
- F# for Trading
- Factor: an extensible interactive language
- Things in Go I Never Use
- Communicating Sequential Goroutines
- Do not fear first class functions
- "go test -race" Under the Hood
- Packet Capture, Analysis, and Injection with Go
- The Design of the Go Assembler
- The Hidden Power of Humble Interfaces
- 7 common mistakes in Go and when to avoid them
- Communicating Sequential Processes
- The move from C to Go in the toolchain
- High Performance Systems in Go
- Three fallacies of dependencies
- Advanced Go Concurrency Patterns
- Go for Pythonistas
- Concurrency is not Parallelism
- Go Concurrency Patterns
- Hackett: a metaprogrammable Haskell
- Laws!
- Linear Haskell: practical linearity in a higher-order polymorphic language
- Suggesting Valid Substitutions For Typed Holes
- Dependent Types in Haskell
- Escape from the ivory tower: the Haskell journey
- Point-Free or Die: Tacit Programming in Haskell and Beyond
- Enigmatic Haskell, Haskellish Enigma
- Framing the Discussion with EDSLs
- Next Level MTL
- Pure Type Systems
- The Road to Running Haskell at Facebook Scale
- Demystifying Haskell
- Getting a Quick Fix on Comonads
- Introduction to Low Level Haskell Optimization
- Safe Zero-Cost Coercions for Haskell
- Writing a game in Haskell
- Lenses, Folds, and Traversals
- The Algebra of Algebraic Data Types
- Haskell Amuse-Bouche
- Data Parallel Haskell
- A History of Haskell: being lazy with class
- Type-driven Development of Communicating Systems in Idris
- Coding for Types: The Universe Pattern in Idris
- Type-Driven Development in Idris
- Dependently Typed Functional Programming with Idris: Introduction
- Dependently Typed Functional Programming with Idris: Embedded DSLs
- Dependently Typed Functional Programming with Idris: Effect Management
- Dependently Typed Functional Programming with Idris: Implementing Idris
- g ∘ f patterns
- A JVM Does That???
- Optional - The Mother of All Bikesheds
- New Concurrency Models on the JVM: Fibres, Verticles, Agents and Actors
- Functional Reactive Programming with RxJava
- Living in the Matrix with Bytecode Manipulation
- Ludicrous Speed: Designing For Performance on the JVM
- Nashorn: implementing a dynamic language runtime on JVM in 2014
- Recursion Schemes
- JVM Bytecode for Dummies (and the Rest of Us Too)
- Effective Java - Still Effective After All These Years
- Learning Functional Programming with JavaScript
- Benchmarking JavaScript
- If you wish to learn ES6/2015 from scratch, you must first invent the universe
- Immutable Data and React
- Improving Your Workflow With Code Transformation
- j2me.js - a multi-threaded Java VM in JavaScript
- Functional programming patterns for the non-mathematician (cut)
- Immutability, interactivity & JavaScript
- Large Scale JavaScript Application Architecture
- Raw WebGL
- Reactive Game Development For The Discerning Hipster
- Constraint programming in the browser
- Creating A Scalable JavaScript Application Architecture
- Monads and Gonads
- Really. JavaScript.
- Redemption from Callback Hell
- Original Node.js presentation
- The Unreasonable Effectiveness of Multiple Dispatch
- Julia as a Platform for Language Development
- The Two Cultures of Programming
- Convex Optimization in Julia
- The Most Beautiful Program Ever Written
- Lisp
- Practical Common Lisp
- Object-Oriented Programming in Objective-C
- Jane and the Compiler
- Why OCaml
- Caml Trading
- Production Prolog
- A Taste of Prolog
- Exploring the CPython JIT
- GraalPy - Fast Python Implementation
- Keynote
- Understanding Python Bytecode
- What Does It Take To Be An Expert At Python?
- Keynote: Built in Super Heroes
- Finding closure with closures
- Machete-mode debugging: Hacking your way out of a tight spot
- Python and Johnny Cash
- Removing Python's GIL: The Gilectomy
- Statistics for Hackers
- Side Effects are a Public API
- Outlier Detection in Time Series Signals
- The Cython Compiler for Python
- Loop like a native: while, for, iterators, generators
- Super Advanced Python
- Transforming Code into Beautiful, Idiomatic Python
- A Python Æsthetic: Beauty and Why I Python
- Inside the Python GIL
- Python Metaprogramming for Mad Scientists and Evil Geniuses
- Understanding the Python GIL
- Slightly Advanced Python: Some Python Internals
- Generic Collections: One Interface to Rule Them All
- Generic Syntax Expanders and Extensible Macros
- The Racket Manifesto
- Purely Functional 3D in Typed Racket
- Composition
- Halve Your Memory Usage With These 12 Weird Tricks
- How Are Method Calls Formed?
- Metaprogramming? Not good enough!
- Methods of Memory Management in MRI
- Building a binary protocol client in Ruby: A magical journey!
- Fun with the Lambda Calculus
- Inside Ruby's VM: The TMI Edition
- Nothing is Something
- Refactoring Ruby with Monads
- A Rubyist in Clojure-land
- Ruby, threads, events ... and Flying Robots!
- That's Not Very Ruby of You
- You Gotta Try This
- Confident Code
- Programming with Nothing
- What Killed Smalltalk Could Kill Ruby, Too
- Miri: Practical Undefined Behavior Detection for Rust
- Rust at speed — building a fast concurrent database
- Using Rust For Game Development
- How I Convinced the World's Largest Package Manager to Use Rust, and So Can You!
- RFC: In Order to Form a More Perfect `union`
- Rusty Runtimes: Building Languages In Rust
- The History of Rust
- The /r/playrust Classifier: Real World Rust Data Science
- Using Generics Effectively
- Cap'n Proto and Rust: Type Systems for Sharing
- Move Over Free Monads: Make Way for Free Applicatives!
- The Dialectics of Type-Level Programming
- Minimizing the Slippery Surface of Failure
- Principles for Modular, Functional, Approachable Libraries
- How types can turn a SQL interpreter into a SQL compiler
- Concurrency Anti-patterns in Scala
- Scala Monads: Declutter Your Code With Monadic Design
- The Nanopass Framework as a Nanopass Compiler
- miniKanren
- Dan Friedman--Cool Ideas (Dan Friedman's 60th Birthday)
- But Really, You Should Learn Smalltalk
- Implementing Swift Generics
- Swift's High-Level IR: A Case Study of Complementing LLVM IR with Language-Specific Optimization
- Unison: An Introduction and Q&A with Rúnar Bjarnason
- Introduction to the Unison Programming Language
- The Unison Language and its Scala-based Runtime
- How to write a search engine in 15 lines of code
- Vim: Tutorial on Editing, Navigation, and File Management
- More Instantly Better Vim
- Vim - I wish I knew how to :q you
- Write code faster: expert-level vim
- Inside the Wolfram Language
- A Beginners' Guide to SelectionDAG
- Auto-Vectorization in HotSpot
- Building Modern Language Frontends with MLIR: Lessons from Mojo's Compile-Time Meta-Programming
- JIT-loading Arbitrary Programs - Powering Xcode Previews with LLVM's JIT
- Specializing MLIR Data Structures: an Experiment
- Datafun: a functional query language
- What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid
- An Introduction to Combinator Compilers and Graph Reduction Machines
- Datafun: A Functional Datalog
- What I learned from LuaJIT
- Bits of advice for VM writers
- Compilers are Databases
- So you want to write an interpreter?
- The movfuscator
- Understanding Compiler Optimization
- VM Design Choices
- Write your own compiler in 24 hours
- Instaparse
- Superoptimizing LLVM
- Writing a Nanopass Compiler
- Implementing Domain Specific Languages with LLVM
- Let's Write an Interpreter!
- The Clang AST - a Tutorial
- How the PyPy JIT works
- Parsing with Derivatives
- The Glitching Hour
- Simit: A Language for Computing on Sparse Systems when Performance Matters
- Making things with maths
- Making WebGL Dance
- The Art of Code
- Creative Computation
- Making Games for 1920s Hardware
- Mapping Imaginary Cities
- Picasso, Geometry, Jupyter
- How to Hack a Painting
- The Symmetries of Things
- Programming In Time - Live Coding for Creative Performances
- Investigating Multithreaded PostgreSQL
- Re-engineering Postgres for Millions of Tenants
- The trouble with extensions
- Jepsen 7: Anna Concurrenina
- Transactions: myths, surprises and opportunities
- Consistency without consensus in production systems
- Jepsen II: Linearizable Boogaloo
- Introduction to NoSQL
- Deconstructing the Database
- How a File Format Led to a Crossword Scandal
- You can't do data science in a GUI
- Data as Software as Data
- Expressing complex data aggregations with Histogrammar
- A CRDT Primer: Defanging Order Theory
- Meetings With Remarkable Trees
- The simple essence of automatic differentiation
- Tree-sitter - a new parsing system for programming tools
- Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step
- Exotic Functional Data Structures: Hitchhiker Trees
- Parsing Text with a Virtual Machine
- Probabilistic Data Structures
- Reasoning about performance (in the context of search)
- An Overview of Probabilistic Programming
- Persistent Data Structures for Special Occasions
- Practical Fractals in Space
- Visualizing Persistent Data Structures
- Generic sorting and partitioning in linear time and fully abstractly
- The Hurricane's Butterfly: Debugging Pathologically Performing Systems
- Tackling Concurrency Bugs with TLA+
- Debugging with the Scientific Method
- Pragmatic Automation
- How Netflix Thinks About DevOps
- Chef Style DevOps Kungfu
- Demystifying SNMP
- I got 10 trillion problems, but logging ain't one
- Your infrastructure is not a unique snowflake, and that's ok!
- How to Find Bugs in Systems That Don't Exist
- Load Balancing is Impossible
- Coordination-Free Computations
- Distributed Eventually Consistent Computations
- Everything Will Flow
- Jepsen IV: Hope Springs Eternal
- K things I know about building Resilient Reactive Systems
- The How and Why of Fitting Things Together
- Improving Yesterday
- Barely succeed! It's easier!
- Time Management
- Why Isn't Functional Programming the Norm?
- What FP can learn from Smalltalk
- Evolving Functional Programming Languages
- Peeling the Banana: Recursion Schemes from First Principles
- Profunctor Optics: The Categorical Approach
- Why Functional Programming Matters
- Functional programming design patterns
- Composable and Compilable Macros
- Unconventional Programming with Chemical Computing
- Functional Programming; What? Why? When?
- Railway oriented programming
- Functional Principles for Object Oriented Development
- Don't fear the Monad
- Faith, Evolution, and Programming Languages
- Tangible Functional Programming
- Is There More to Game Architecture than ECS?
- What Every Programmer Should Know about How CPUs Work
- A Taste of GPU Compute
- eMMC hacking, or: how I fixed long-dead Galaxy S3 phones
- Mill vs. Spectre: Performance and Security
- A Crash Course in Modern Hardware
- The Future of Microprocessors
- Let's Build a Computer!
- Constraint Logic Propagation Conflict Spreadsheets
- Challenges for Logic Programming
- 2024 in Post-Transformer Architectures: State Space Models, RWKV
- The Unreasonable Effectiveness of Deep Learning
- Automatic Algorithm Invention with a GPU
- The Unreasonable Effectiveness of Data
- Category Theory
- Constructive Type Theory and Homotopy
- Homoiconicity: It Is What It Is
- How we program multicores
- Simplicity is Complicated
- Make Simple Tasks Simple!
- Programming Should Eat Itself
- Why C++ Sails When the Vasa Sank
- Running a startup on Haskell
- Scaling Yourself
- X Marks the Spot: Navigating Possible Futures with Wardley Maps
- Dealing with unanticipated needs
- How to be a Happy Developer. Now!
- Stewardship Made Practical
- Jolly JS Journeys
- Shaping our children's education in computing
- The Hard Parts of Open Source
- Code Review, Forwards and Back
- Crossing the River by Feeling the Stones
- Forget Velocity, Let's Talk Acceleration
- Idée Fixe
- Invited Talk
- On Abstraction
- Winning the War on Error: Solving Halting Problem, Curing Cancer
- extern c: Talking to C Programmers about C++
- Humanizing among coders
- It's Simple…
- Software, Faster
- "Am I Senior Yet?" Grow Your Career by Teaching Your Peers
- Being Human
- You are Not an Impostor
- Career Advice for Programmers
- Patterns in Architecture
- Normal Considered Harmful
- "You can be a kernel hacker!"
- Python, Linkers, and Virtual Memory
- The Origins of Linux
- Performance Matters
- Software Performance: A Shape Not a Number
- Designing for Performance
- Do Programming Language Features Deliver on their Promises
- Jai Demo and Design Explanation (KEYNOTE)
- My favorite verbose programming technique
- On the Expressive Power of Programming Languages
- Stuck macros: deterministically interleaving macro-expansion and typechecking
- A Little Taste of Dependent Types
- A Tale of Two Asyncs: Open Source Language Design in Rust and Node.js
- Four Languages from Forty Years Ago
- Gradual typing of Ruby at Scale
- Proof Theory Impressionism: Blurring the Curry-Howard Line
- Running With Scissors: Live Coding With Data
- Into the Core - Squeezing Haskell into Nine Constructors
- Let's Build a Hygienic Macro Expander
- Make Your Own Programming Language!
- Sketch-n-Sketch: Interactive SVG Programming with Direct Manipulation
- Everything old is new again: Quoted domain specific languages
- I See What You Mean
- Let's be mainstream! User focused design in Elm
- Fundamental Concepts in Programming Languages
- Propositions as Types
- Syntaxation
- Implement an Esoteric Programming Language for Fun
- The Sociology of Programming Languages
- Transducers
- A Dinosaur's Thoughts on Programming Language Evolution
- Type-Driven Program Synthesis
- Barliman: trying the halting problem backwards, blindfolded
- How to Give a Great Research Talk
- Lessons From Two Years of Crypto Audits
- DNS over HTTPS considerations
- GOD MODE UNLOCKED - Hardware Backdoors in x86 CPUs
- Q: Why Do Keynote Speakers Keep Suggesting That Improving Security Is Possible?
- WebAssembly: A New World of Native Exploits on the Browser
- You're Probably Not Red Teaming... And Usually I'm Not, Either
- Breaking the x86 Instruction Set
- Exploit Kit Cornucopia
- Ichthyology: Phishing as a Science
- Repsych: Psychological Warfare in Reverse Engineering
- Pulling Back the Curtain on Airport Security: Can a Weapon Get Past TSA?
- The Science of Insecurity
- System Daydreams and Logarithmic Colored Glasses
- The Best Simple System for Now
- Is Software Engineering Real Engineering?
- Intro to Empirical Software Engineering: What We Know We Don't Know
- Moldable development
- Say What You Mean - Exploring Declarative Computation in Art
- Sherlock Holmes, Consulting Developer
- A Philosophy of Software Design
- Old Is the New New
- OOP Is Dead, Long Live Data-oriented Design
- Programming Across Paradigms
- TDD, Where Did It All Go Wrong
- Things that Matter
- You're Insufficiently Persuasive
- Get a Whiff of This
- Small Is Beautiful
- The Error of Our Ways
- The Programmer
- Apparatus: A Hybrid Graphics Editor / Programming Environment
- Boundaries
- Conceptualizing Large Software Systems
- One Hacker Way
- Scalable is Awesome, Literally!
- All the Little Things
- Kicking the Complexity Habit
- "Uncle" Bob Martin
- Thinking Above the Code
- What does it mean to be Reactive?
- I have a good feeling about this. Why tooling is poised to make the jump to hyperspace
- Programming is terrible—Lessons learned from a life wasted
- The Future of Programming
- The Language of the System
- The Not-So-Big Software Design
- Growing a Language
- Hammock Driven Development
- Simplicity Matters
- Architecture the Lost Years
- Real Software Engineering
- SOLID Object-Oriented Design
- The Salami Method for Cross Platform Development
- Mastering Chaos - A Netflix Guide to Microservices
- Kill "Microservices" before its too late
- Runtime scheduling: theory and reality
- Power Use of UNIX
- Keeping a System Running Forever
- Speed & Scale: How to Get There
- Narcissistic Design
- Scalability at YouTube
- Reliability Lessons From SQLite
- How to Stop Hating Your Tests
- Testing the Hard Stuff and Staying Sane
- Category Theory for the Working Hacker
- A Lever for the Mind
- Impossible Programs
- An Axiomatic Basis for Computer Programming
- Lambda Calculus Then and Now
- Church's Coincidences
- Programming the Turing Machine
- Turing and the Riemann zeta function
- Type Theory and its Meaning Explanations
- On the Meanings of the Logical Constants
- The Derivative of a Regular Type is its Type of One-Hole Contexts
- Data Driven UIs, Incrementally
- Practical UI physics
- We Will All Be Game Programmers
- Methods & Techniques to Making Good User Interfaces
- How I Learned to Code by Making 180 Websites in 180 Days
- How NOT to Measure Latency
- The Website Obesity Crisis
- Upgrading the Web
- Hacker Way: Rethinking Web App Development at Facebook
- Immutability: Putting The Dream Machine To Work
- React: RESTful UI Rendering
- An End to Negativity
- C10M: Defending The Internet At Scale
- community.js
- Preventing the Collapse of Civilization
- Soul from Scratch: Designing a More Portable Organ
- Keynote
- LIGO: The Dawn of Gravitational Wave Astronomy
- Juggling Patterns and Programs
- A Brief History of Time
- Keynote
- Kolmogorov music
- Well I Wouldn't Want To Make a *Dys*functional Game
- Stop Treading Water: Learning to Learn
- Madam Sandi Tells Your Future
- Software Development Lessons from the Apollo Program
- States and Nomads: Handling Software Complexity
- Clojure: Programming with Hand Tools
- How To Shut Down Tolkien
- To the Moon!
- Keynote
- "It's not what you read, it's what you ignore"
- Linus Torvalds on git
- The Computer Revolution Hasn't Happened Yet
- Programming is terrible — Lessons learned from a life wasted
- Effective Programs - 10 Years of Clojure
- The Web We Lost
- Simplify Challenging Software Problems with Rocket Science
- Why agile
- Linus Torvalds & git
- The Worst Programming Language Ever
- Programming is writing is programming
- We're Doing It All Wrong
- Real Software Engineering
- Feature Branching Considered Evil
- Programming's Greatest Mistakes
- Email vs Capitalism: A Story About Why We Can't Have Nice Things
- Being the Human in the Loop
- Rethinking software development: insights from 20+ years in the field
- Functional is cool, but do you know OO
- Extreme Cleverness: Functional Data Structures in Scala
- Types are like the Weather, Type Systems are like Weathermen
- Functional architecture - The pits of success
- To Clojure and back: writing and rewriting in Ruby
- All I needed for FP I learned in High School Algebra
- The Art of Destroying Software
- The Actor Model (everything you wanted to know...)
- How To Design A Good API and Why it Matters
- Stewardship: the Sobering Parts
- Therapeutic Refactoring
- Evidence-Oriented Programming
- The Programming Language Wars
- Hopelessness and Confidence in Distributed Systems Design
- Tidy First? Kent Beck on Refactoring
- The Better Parts
- Critical rendering path - Crash course on web performance
- The Transformation Priority Premise
- Test-driven development: Write better code in less time
- The Magic Tricks of Testing
- Why You Don't Get Mock Objects
- The Clean Code Talks -- Unit Testing
- TDD and Software Design
- Does TDD Really Lead to Good Design?
- TDD: Theme & Variations
- The Land that Scrum Forgot
- Demanding Professionalism in Software Development
- The Death of Agile
- Opening keynote - Why Agile Works
- Extreme product development
- LLM-assisted coding - A Systems Perspective
- The Charming Genius of the Apollo Guidance Computer
- The History (and the Future) of Software
- The Future of Programming
- 1968
- DOOM's Development: A Year of Madness
- The Boeing 737 MAX: When Humans and Technology Don't Mix
- Things every developer absolutely, positively needs to know about database indexing
- Acceptance Testing For Continuous Delivery
- Patterns for Coding with AI
- Surviving the Framework Hype Cycle
- The Perils of Inheritance: Why We Should Prefer Composition
- Extreme Programming 20 years later
- A Programmer's Guide to Public Speaking
- Kill Your Inner Code Monkey
- Measuring and Optimizing Tail Latency
- Inventing on Principle
- Media for Thinking the Unthinkable
- Finding a Way Out
- Computers are a Sadness, I am the Cure
- Are We There Yet?
- The Value of Values
- Stop Writing Classes
- Micro-Service Architecture
- Crafting Wicked Domain Models
- Integrated Tests Are A Scam
- Structure and Interpretation of Test Cases
- Moving Past the Scaling Myth
- How to Think about Parallel Programming: Not!
- Y Not - Adventures in Functional Programming
Deutsch — 161 talks
- Knigge für Softwarearchitekten
- OpenTelemetry – ein offener Standard für den Durchblick in Anwendungslandschaften
- Missverständnisse zu Softwarearchitektur
- Mehr als eine Abfragesprache: SQL im 21. Jahrhundert
- Event Storming für Domain-driven Design
- LLMs im Griff: Observability, Tracing und Security
- Jenseits von Technologie – die 10 Ks in Software-Architektur
- Traue keinem Scan, den du nicht selbst gefälscht hast
- Warum funktioniert Continuous Delivery nicht?
- Models, Modules, Microservices – bessere Domänenmodelle mit den Modulen aus Java 9
- Kill the Vibe? Architektur im AI-Zeitalter
- Wenn das Wissen die Firma verlässt und die Software bleibt
- Softwarearchitektur: Events, Events, überall Events!
- Traditionelle Softwareentwicklung oder Machine Learning?
- Die richtige Wahl bei Frontend-Technologie
- Hilfe, ich will meinen Monolithen zurück!
- State of Domain Driven Design
- Modularisierung: Grundlage für Microservices und Monolithen
- Die sieben Herausforderungen resilienten Softwaredesigns
- Conway’s Law und Soziologie in der Softwarearchitektur
- Frontend-Monolithen — eine einvernehmliche Trennung?
- Bessere Monolithen – modulithische Applikationen mit Spring Boot
- Domain-driven UX Design
- Hallo REST API, wie geht es jetzt weiter?
- Einführung in die funktionale Softwarearchitektur
- Event Sourcing für die Praxis
- Langlebige Softwarearchitekturen, die Jahrzehnte überdauern
- 10 Gründe, warum wir gewisse APIs mögen und uns andere APIs nerven
- Zeitloses Design für Cloud-native Systeme
- API-Design – Tipps aus der Praxis
- Wie werde ich ein erfolgreicher Softwarearchitekt?
- The easy Way to secure Microservices
- Majestic Modular Monoliths
- Integration Patterns for Microservices
- Opportunities and Pitfalls of Event-driven Utopia
- Eine Einführung ins Identity Management: Von Access, Berechtigungen, Cloud ...
- Die Revolution frisst ihre Kinder - wie ChatGPT & Co. den IT-Sektor disruptiert
- Frischer Wind für Legacy-Software: Wie man alte Anwendungen auf neue Beine stellt
- Mocks, Fakes, Stubs – ist da ein Unterschied? Braucht man das noch?
- JobCoach goes GPT: Failures, Trials and Triumphs
- Orchestrierung mit Nomad
- Open Source-Entertainment: Vim für schnelles und nachhaltiges Coden!
- Shared Responsibility - Vom Anfang und Ende der Verantwortung in der Cloud
- Inspect & Adapt – agile Elementarteilchen
- Microservices – ein Fazit
- Mob-Programming: Zusammen lernen, zusammen liefern!
- Web-Apps ohne Frameworks #slideless #nomigrations
- Der Rausch der Geschwindigkeit – Nutzerwahrnehmung aktiv beeinflussen
- Mastering Cargo Cult – Dunning, Kruger und die Agile Bias Curve
- API-Design – Wie man es besser (nicht) macht
- 7 Tipps für eine verständliche Git-Historie
- Wie führt man DDD erfolgreich in Unternehmen ein?
- Frontend-Architektur für Microservices
- Wartbare Architekturen mit Angular, Monorepos und Strategic Domain-driven Design
- Herausforderung Veränderung: Modelle, Grenzen und der Einfluss von Kultur
- DevOps Realitätscheck: Gefühlt schneller oder echt schneller?
- Embabel: Agentic AI planen statt prompten
- Wie funktionieren neuronale Netze? #underthehood
- Machine Learning: das Ende der Businesslogik?
- Modernes SQL: Evolution eines Dinosauriers
- Wie moderne SQL-Datenbanken auf Algorithmen kommen, von denen du nie geträumt hättest
- Von wegen Eisblumen! Wie man mit Code, Satelliten und Schiffsexpeditionen die bunte Welt des
- WissPod Jahresrückblick 2025 oder: KI in der Wissenschaft!?
- Auf die Dauer hilft nur Power: Herausforderungen für dezentrale Netzwerke aus Sicht der Soziologie
- GPTDash – Der Reverse-Turing-Test
- Gemeinsam Wissens-Infrastruktur bauen: föderierte Wikibase für Video- und Podcast
- Medikationsplan24.ti - der digital gerührte Medikationsprozess
- Besser Tunneln mit SSH
- Bluetooth-Smart-Kommunikation von Gadgets analysieren
- Privilege Escalation – Zugriffsfähigkeiten im Namen der Sicherheit
- De-Spotify Yourself - Warum Du von $Streamingdienst weg willst und wie/wohin
- [decryptoparty] - Unabled to stay encrypted
- Digitale Stellwerke - digitale Pläne?
- Wie steuert man eigentlich ein Museum?
- Digitalisierung in der Medizin – elektronische Patientenakte (ePA) für alle? SOS
- Verdinglichte Entwicklungen: Aus der Küche zur integrierten Entwicklungsumgebung
- Kindgerechte Systemarchitektur: Die Open Source-Musikbox “TonBERRY pico”
- Just Another IPv6 Talk
- Was ist dieses smart in SmartHome?
- Hexagonale Architektur in Microservices
- Den Flaschenhals in einer langsamen Pipe optimieren durch Parallelisierung
- IoT in der Luftfahrt
- Everything-as-Code – Anything Secure?
- Anycast all the things - Lastverteilung und Redundanz im eigenen Netz
- Snabb: fast software networking made simple
- Open Source Firmware
- Warum Go?
- Matrix
- Softwarequalität === Gesundheit
- State of the Union 2019
- Privacy by design
- Retrogaming und -computing
- Linux Paketfiltering reloaded
- Folgeabschätzung meines Programms
- Apache Kafka: Lessons learned
- IPv6 im Jahre 2018
- Netzwerkgrundlagen - Von Ethernet bis IP
- Dynamische Routingprotokolle Aufzucht und Pflege - BGP
- Nebenläufige reaktive Programmierung mit Go
- Paketfiltern und mehr mit netfilter
- Unter der Haube der JVM
- Open Source darf auch was kosten
- Meltdown and Spectre... for normal people
- OSI Layer 8
- Open Source in the WSN Research
- FAIR Data Prinzipien, Transparenz und Reproduzierbarkeit im Kontext von Open Source Software
- Overlays & IP-Fabrics - viele Wege führen nach Rom und warum Layer2 keine Lösung ist
- Dynamische Routingprotokolle Aufzucht und Pflege - OSPF
- Apache Kafka
- L2/L3 für Fortgeschrittene - Helle und dunkle Magie im Linux-Netzwerkstack
- We do Privacy by Design
- Volkskrankheit "stiefmütterliche SQL-Indizierung"
- Datenschutz und Softwaregestaltung
- Segment Routing
- How to Prototype Fund
- MQTT
- Patch Rejected
- Resiliency als Beifahrer
- Best Current Operational Practices - Dos, Don'ts and lessons learned
- Bessere Microservices mit Domain Driven Design
- DNSSEC, DMARC, DKIM und SPF im Einsatz
- Fuzz testing von SQL-Datenbanksystemen
- Don't scroll - Entscheidungsunterstützung im biomedizinischen Bereich jenseits von Excel
- Was Du schon immer über Netzwerke wissen wolltest, Dich aber nie getraut hast zu fragen.
- Modular Web
- Standards für barrierefreie Webseiten
- Limux: das Ende eines Leuchtturm-Projekts!?
- Sicheres Löschen von Daten auf SSDs
- Das X markiert die Stelle!
- Es muss mal wieder SHELL sein...
- Extraktion von Microservices aus einem Monolithen
- struggling with open data in public transport
- General Data Protection Regulation is coming
- SELinux und AppArmor
- Lessons Learned ...
- Fehlertolerante und skalierbare Systeme mit dem Netflix OSS
- Eine Einführung in Ontologien
- Aufbau eines Schulnetzwerkes
- Überwache deine Services
- Nicht alltägliche Git-Funktionen
- Rise and Fall of Bananian Linux
- Virtual Observatory
- Sieben Deployment Sünden
- Geodaten als Datenbank und ihre Lizenzierung
- Practical Content Encryption
- Domain Driven Design damals und heute
- Clean Code
- Wissenschaft & Open Source - It's Complicated
- Get to know OSGeo FOSSGIS FOSS4G OSM
- Herausforderungen bei der Einführung von Open Source Technologien in Unternehmen
- Betriebssystemwechsel von VMS nach Linux am Beispiel einer Produktionsumgebung
- Kotlin in Produktion
- Funding für Open Source – Wer, Wie und Warum?
- Æ-DIR
- Principles of Design in Software Systemen
- D.R.Y. Don't repeat yourself
- PostgreSQL in der Praxis
- Die Testing-Zonen
- Cassandra on Steroids
- Mit Shell-Skripten zum Kernel-Treiber für neue HW
- Optimizing the Driving Behavior of Self-Driving Cars Using Genetic Algorithms