All Episodes
Coding Blocks — 242 episodes
When to Log Out
Things to Know when Considering Multi-Tenant or Multi-Threaded Applications
Two Water Coolers Walk Into a Bar
How did We Even Arrive Here?
AI, Blank Pages, and Client Libraries...oh my!
Alternatives to Administering and Running Apache Kafka
Nuts and Bolts of Apache Kafka
Intro to Apache Kafka
StackOverflow AI Disagreements, Kotlin Coroutines and More
Llama 3 is Here, Spending Time on Environmental Setup and More
Ktor, Logging Ideas, and Plugin Safety
Importance of Data Structures, Bad Documentation and Comments and More
Decorating your Home Office
Multi-Value, Spatial, and Event Store Databases
Overview of Object Oriented, Wide Column, and Vector Databases
Picking the Right Database Type - Tougher than You Think
There is still cool stuff on the internet
Reflecting on 2023 and Looking Forward to 2024
Gartner Top Strategic Technology Trends 2024
2023 Holiday Season Developer Shopping List
Gartner and your Life Partners
Open Telemetry - Instrumentation and Metrics
Keyboards, Cloud Costs, Static Analysis, and Philosophy
Code Confidence using NASA's Ten Simple Rules
GitHub Actions
Tracing Specifics - Know your System with OpenTelmetry
What is OpenTelemetry?
Software in Audio and How to Lead
Team Leadership, TUIs, and AI Lawsuits
Better Application Management with Custom Apps
Errors vs Exceptions, Reddit Rebels, and the 2023 StackOverflow Survey
Easy and Cheap AI for Developers, Reddit API Changes and Sherlocking
Gitlab vs Github, AI vs Microservices
Supporting Your Code, README vs Wiki and Test Coverage
Water Cooler Gpt
Understanding Serial Transactions for Databases like Redis
Designing Data-Intensive Applications – Lost Updates and Write Skew
ChatGPT and the Future of Everything
Designing Data-Intensive Applications – Weak Isolation and Snapshotting
Designing Data-Intensive Applications – Multi-Object Transactions
Designing Data-Intensive Applications – Transactions
2023 Resolutions
200th Episode Extravaganza!
Job Hopping an Favorite Dev Books
Technical Challenges of Scale at Twitter
The 2022 Shopping Spree
As the Watercooler Turns
Git from the Bottom Up – Reset, Stash, and Reflog
Git from the Bottom Up – The Index
Git from the Bottom Up – Rebasing
Git from the Bottom Up - Commits
Git from the Bottom Up – Blobs and Trees
Understanding Git
Stack Overflow 2022 Survey Says …
Site Reliability Engineering – More Evolution of Automation
Site Reliability Engineering - Evolution of Automation
Site Reliability Engineering - (Still) Monitoring Distributed Systems
Site Reliability Engineering - Monitoring Distributed Systems
Site Reliability Engineering - Eliminating Toil
Site Reliability Engineering – Service Level Indicators, Objectives, and Agreements
Site Reliability Engineering - Embracing Risk
Software Reliability Engineering - Hope is not a strategy
The Great Resignation
Minimum Viable Continuous Delivery
#CBJAM 22 Recap
PagerDuty's Security Training for Engineers, The Dramatic Conclusion
PagerDuty's Security Training for Engineers, Penultimate
PagerDuty's Security Training for Engineers! Part Deux
PagerDuty's Security Training for Engineers
What is a Game Engine?
Designing Data-Intensive Applications – Secondary Indexes, Rebalancing, Routing
Designing Data-Intensive Applications – Partitioning
The 2021 Shopping Spree
Should You Speak at a Conference?
Transactions in Distributed Systems
Docker Licensing, Career and Coding Questions
Why Get Into Competitive Programming?
Are Microservices … for real?
2021 State of the Developer Ecosystem
What is GitHub Copilot?
Designing Data-Intensive Applications – Leaderless Replication
Designing Data-Intensive Applications – Multi-Leader Replication
Designing Data-Intensive Applications – Single Leader Replication
Some Fun APIs
Making Money with Code
Write Great APIs
How to Scrum
What is Scrum?
Show Recursion Show
Specialize or Bounce Around?
Why is Python Popular?
Game Jam Lessons Learned
Who Owns Open-Source Software?
Our Favorite Developer Tools of 2020
Into the Octoverse
We <3 Kubernetes
What is a Developer Game Jam?
The DevOps Handbook - Create Organizational Learning
The 2020 Shopping Spree
The DevOps Handbook – Enable Daily Learning
The DevOps Handbook – The Value of A/B Testing
Is Kubernetes Programming?
The DevOps Handbook – Enabling Safe Deployments
The DevOps Handbook – Anticipating Problems
The DevOps Handbook – The Technical Practices of Feedback
The DevOps Handbook – Architecting for Low-Risk Releases
The DevOps Handbook - The Technical Practices of Flow
Survey Says ... 2020 Stack Overflow Developer Survey
Google's Engineering Practices – How to Navigate a Code Review
Google's Engineering Practices - What to Look for in a Code Review
Google's Engineering Practices – Code Review Standards
Big Data - How Far is Too Far?
Designing Data-Intensive Applications - To B-Tree or not to B-Tree
How to Work Remote Effectively
Designing Data-Intensive Applications - SSTables and LSM-Trees
Designing Data-Intensive Applications – Storage and Retrieval
Why Attend Developer Conferences and What were the Hot Topics at NDC London 2020?
Designing Data-Intensive Applications – Data Models: Query Languages
Designing Data-Intensive Applications – Data Models: Relationships
Designing Data-Intensive Applications - Data Models: Relational vs Document
Designing Data-Intensive Applications – Maintainability
Designing Data-Intensive Applications – Scalability
Designing Data-Intensive Applications - Reliability
Developer Shopping Spree 2019
DevOps: Job Title or Job Responsibility?
3factor app - Async Serverless
3factor app - Reliable Eventing
3factor app - Realtime GraphQL
The Pragmatic Programmer - How to Build Pragmatic Teams
The Pragmatic Programmer - How to use Exceptions
The Pragmatic Programmer - How to Generate Code
The Pragmatic Programmer - How to Debug
The Pragmatic Programmer - Know Thy Tools
The Pragmatic Programmer - How to Estimate
The Pragmatic Programmer - Tracer Bullets and Prototyping
The Pragmatic Programmer - Is Your Code Orthogonal?
The Pragmatic Programmer - The Evils of Duplication
The Pragmatic Programmer - Investing in Your Knowledge Portfolio
Should your web app be a progressive web app (PWA)?
The Second Date is Always Easier
Why Date-ing is Hard
What Should You Learn Next?
Tackling Tough Developer Questions
JAMstack with J.A.M.
Data Structures - Heaps and Tries
Data Structures - (some) Trees
Data Structures - Hashtable vs Dictionary
Data Structures - Arrays and Array-ish
Data Structures - Primitives
Developer Shopping Spree
Azure Functions and CosmosDB from MS Ignite
How to Learn Programming Skills
Comparing Git Workflows
Does Big O Matter?
What is Algorithmic Complexity?
Thunder Talks
Lightning Talks
Graph Algorithms
Algorithms You Should Know
Search Driven Apps
Programmer Strengths and Weaknesses
Understanding Complexity Theory
Docker for Developers
Design Anti-Patterns: YoYo, The God Object and More
Deliberate Practice for Programmers
Clean Architecture - Are Microservices Truly Decoupled?
Clean Architecture - What is the Humble Object Pattern?
Clean Architecture - Make Your Architecture Scream
Clean Architecture - The Art of Drawing Lines
Clean Architecture - Keeping Your Options Open
Clean Architecture - How to Quantify Component Coupling
Clean Architecture - Components and Component Cohesion
How to Spend $2,500 on Developer Gear
Clean Architecture - Programming Paradigms
Clean Architecture - Fight for Architecture
Object Oriented Mistakes
Project Management Anti-patterns
Software Design Anti-patterns
What is Supple Design?
Explicit Constraints, Processes, Specification Pattern, and more
Strategic Design and Domain Events
Aggregate Roots, Factories, and Repositories
The Domain in Domain Driven Design
How to Jumpstart Your Next App
Why Domain Driven Design
How We Badly Built Stuff
Clean Code - How to Build Maintainable Systems
Clean Code - How to Write Classes the Right Way
Clean Code - How to Write Amazing Unit Tests
Clean Code - Integrating with Third Party Libraries the Right Way
Clean Code - Error Handling
Clean Code - Objects vs Data Structures
Clean Code - Formatting Matters
Clean Code - Comments Are Lies
Clean Code - How to Write Amazing Functions
Clean Code - Writing Meaningful Names
Caching in the Application Framework
Caching Overview and Hardware
Stack Overflow Salaries and Landing the Job
Nulls, Procs, and Imposter Syndrome
Command, Repository and Mediator Design Patterns
Dev Talk: Django, VB vs C#, and Bash on Windows
How to be an Advanced Programmer
How to be an Intermediate Programmer
How to be a Programmer
Our Favorite Developer Tools for 2015
The Twelve-Factor App: Dev/Prod Parity, Logs, and Admin Processes
The Twelve-Factor App: Port Binding, Concurrency, and Disposability
Toys for Developers
The Twelve-Factor App: Backing Services, Building and Releasing, Stateless Processes
The Twelve-Factor App: Codebase, Dependencies, and Config
Javascript Promises and Beyond
Design Patterns Part 4 - Adapter, Facade, and Memento
Hierarchical Data cont'd - Path Enumeration and Closure Tables
Hierarchical Data – Adjacency Lists and Nested Set Models
Your Questions Our Answers SYN-ACK with Packet Loss
Algorithms, Puzzles and the Technical Interview
ASP.NET 5 - It's Basically Java
Delegate all the things!
Back to Basics - Encapsulation for Object Oriented Programming
Silverlighting through your College Enumeration
Our Favorite Tools
We're Testing Your Patience...
Design Patterns Part 3
You Asked For It
Got Any Hot Stacks?
Behavioral Patterns Pt 1
NDepends on How Good Your Code Is
Databases the SQL [see-kwuhl]
All Your Database Are Belong to Us
What do you want to be when you grow up?
Design Patterns Part 1
C# 6 and Roslyn
Aspectacular with Vlad Hrybok
T'ings We Like
SOLID as a Rock
There's Something About LINQ
We Still Don't Understand Open Source Licensing
OWASP and You - Application Security in .NET
Source Control Etiquette
Boxing and Unboxing in .NET
I is for Interface