Beste Backend podcaster (2024)

1
The genius of long polling 28:57

25d ago28:57

28:57

Polling is the ability to interrogate a backend to see if a piece of information is ready. It can introduce a chatty system and as a result long polling was born. In this video I explain the beauty of this design pattern and how we can push it to its limit. 0:00 Intro0:45 Polling2:30 Problem with Polling3:50 Long Polling8:18 Timeouts10:00 Long Poll…

1
Six stages of a good software engineer 39:27

2M ago39:27

39:27

You get better as a software engineer when you go through these stages. 0:00 Intro 1:15 Understand a technology 7:07 Articulate how it works 15:30 Understand its’ limitations 19:48 Try to build something better 27:45 Realize what you built also has limitations 32:48 Appreciate the original tech as is Understand a technology We use technologies all …

1
This new Linux patch can speed up Reading Requests 18:12

2M ago18:12

18:12

Fundamentals of Operating Systems Course https://oscourse.winVery clever! We often call read/rcv system call to read requests from a connection, this copies data from kernel receive buffer to user space which has a cost. This new patch changes this to allow zero copy with notification. “Reading' data out of a socket instead becomes a “notification”…

1
Cloudflare's 150ms global cache purge | Deep Dive 1:02:21

2M ago1:02:21

1:02:21

Cloudflare built a global cache purge system that runs under 150 ms. This is how they did it. Using RockDB to maintain local CDN cache, and a peer-to-peer data center distributed system and clever engineering, they went from 1.5 second purge, down to 150 ms. However, this isn’t full picture, because that 150 ms is just actually the P50. In this vid…

1
MySQL is having a bumpy journey 28:34

3M ago28:34

28:34

Fundamentals of Database Engineering udemy course https://databases.winMySQL has been having bumpy journey since 2018 with the release of the version 8.0. Critical crashes that made to the final product, significant performance regressions, and tons of stability and bugs issues. In this video I explore what happened to MySql, are these issues getti…

1
How many kernel calls in NodeJS vs Bun vs Python vs native C 20:41

3M ago20:41

20:41

Fundamentals of Operating Systems Course https://oscourse.winIn this video I use strace a performance tool that measures how many system calls does a process makes. We compare a simple task of reading from a file, and we run the program in different runtimes, namely nodejs, buns , python and native C. We discuss the cost of kernel mode switches, sy…

1
When do you use threads? 31:08

4M ago31:08

31:08

Fundamentals of Operating Systems Course https://os.husseinnasser.comWhen do you use threads?I would say in scenarios where the task is either 1) IO blocking task2) CPU heavy3) Large volume of small tasksIn any of the cases above, it is favorable to offload the task to a thread.1) IO blocking taskWhen you read from or write to disk, depending on ho…

1
Frontend and Backends Timeouts 25:23

4M ago25:23

25:23

I am fascinated by how timeouts affect backend and frontend programming. When a party is waiting on something you can place a timeout to break the wait. This is useful for freeing resources to more critical processes, detecting slow operations and even avoiding DOS attacks. Contrary to common beliefs, timeouts are not exclusive to request processin…

1
Postgres is combining IO in version 17 27:39

4M ago27:39

27:39

Learn more about database and OS internals, check out my courses Fundamentals of database engineering https://databases.win Fundamentals of operating systems https://oscourse.win This new PostgreSQL 17 feature is game changer. You see, postgres like most databases work with fixed size pages. Pretty much everything is in this format, indexes, table …

1
#069 - Season Finale: The Boot.dev Origin Story w/ Allan 1:14:49

4M ago1:14:49

1:14:49

Today, we bring you the final episode of the first season of Backend Banter! It’s a wrap up for now. With 69 episodes behind us, we want to tell you the story of Boot Dev and how far we’ve come from our beginnings, and for that, we bring Allan Lires, the first official employee and the second person to work on our platform! We’re going to cover our…

1
Windows vs Linux Kernel 37:23

4M ago37:23

37:23

Fundamentals of Operating Systems Course https://os.husseinnasser.comWhy Windows Kernel connects slower than Linux I explore the behavior of TCP/IP stack in Windows kernel when it receives a RST from the backend server especially when the host is available but the port we are trying to connect to is not. This behavior is exacerbated by having both …

1
Designing Scalable Solutions: Building a URL Shortener Like bit.ly and TinyURL 9:28

4M ago9:28

9:28

Dive into the world of system design as we explore the intricacies of building a scalable URL shortener service like bit.ly and TinyURL. In this episode, we explore: The core components of a URL shortener and the fascinating process of generating short links Cutting-edge scalability strategies to handle millions of requests efficiently Real-world c…

1
Designing a Scalable Load Balancer for High-Traffic Web Apps: Fault Tolerance Explained 14:24

4M ago14:24

14:24

Dive into the world of load balancers and learn how to design a scalable, fault-tolerant system for high-traffic web applications. In this episode, we explore: Load balancing algorithms and health checks: Discover the best strategies for distributing traffic and maintaining system health Scalability techniques and handling traffic spikes: Learn the…

1
Understanding and Avoiding Deadlocks in OS and Concurrent Programming 10:36

4M ago10:36

10:36

Dive into the world of deadlocks in operating systems and concurrent programming with expert insights from senior backend engineer Victor. In this episode, we explore: The four crucial conditions for deadlocks and how to remember them Effective strategies to prevent and detect deadlocks in various scenarios Real-world examples and edge cases, inclu…

1
Sharding vs. Replication: A Face-Off of Strategies for Database Scaling 10:44

4M ago10:44

10:44

Dive into the world of database scaling strategies as we pit sharding against replication in this informative episode. In this episode, we explore: Sharding vs. Replication fundamentals: Uncover the key differences between these two powerful database scaling techniques Scaling and performance benefits: Learn how each strategy tackles the challenges…

1
Balancing Backward Compatibility and Innovation in API Design: Best Practices and Challenges 12:33

4M ago12:33

12:33

Dive into the intricate world of API design as we explore the delicate balance between maintaining compatibility and driving innovation. In this episode, we explore: Backward and forward compatibility: Unraveling these crucial concepts and their impact on API design The compatibility conundrum: Strategies for introducing new features without breaki…

1
Demystifying CQRS: Understanding the Command Query Responsibility Segregation Pattern in Software Architecture 10:58

4M ago10:58

10:58

Dive into the world of Command Query Responsibility Segregation (CQRS) and discover how this powerful architectural pattern can revolutionize your software design. In this episode, we explore: Understanding CQRS: Core principles and how it differs from traditional CRUD models Implementing CQRS: Best practices, potential challenges, and strategies f…

1
Semaphores vs. Mutexes: A Deep Dive into Synchronization Primitives 11:15

4M ago11:15

11:15

Dive into the world of synchronization primitives with an in-depth comparison of semaphores and mutexes in operating systems and concurrent programming. In this episode, we explore: The fundamental differences between semaphores and mutexes, and when to use each Real-world applications, from managing hotel rooms to coordinating chefs and waiters Co…

1
Understanding HTTP 4xx Status Codes: Key Indicators in Web Communication 9:02

4M ago9:02

9:02

Dive into the world of HTTP 4xx status codes and their crucial role in web communication with this informative episode of Networking Interview Crashcasts. In this episode, we explore: Common 4xx status codes and their meanings in client-side errors Real-world applications and intriguing edge cases of 4xx codes Best practices for implementing status…

1
The Consumer-Partition Balancing Act: When Consumers Outnumber Partitions 9:32

4M ago9:32

9:32

Dive into the intricate world of Apache Kafka as we explore the delicate balance between consumers and partitions in this enlightening episode. In this episode, we explore: The fascinating dynamics when consumers outnumber partitions in Kafka Kafka's clever rebalancing mechanism for fair workload distribution Real-world implications for scalability…

1
JVM Deep Dive: Garbage Collection and Memory Management Beyond the Heap 11:34

4M ago11:34

11:34

Dive deep into the intricate world of JVM internals and unlock the secrets to optimizing your Java applications' performance. In this episode, we explore: The ins and outs of garbage collection and memory management in the JVM A tour of memory areas beyond the heap and their crucial roles An in-depth look at various garbage collection algorithms an…

1
The Rise of GraalVM, HotSpot, and Quarkus: Exploring Java's Evolving Ecosystem 8:11

4M ago8:11

8:11

Dive into the cutting-edge world of Java technologies as we explore the rise of GraalVM, HotSpot, and Quarkus in this enlightening episode. In this episode, we explore: The evolution of Java performance: From HotSpot's adaptive optimization to GraalVM's versatility Ahead-of-Time vs. Just-in-Time compilation: Unraveling the key differences and use c…

1
Database Isolation Levels: Balancing Consistency and Performance in Your Applications 9:36

4M ago9:36

9:36

Dive into the world of database isolation levels and learn how to balance data consistency with performance in your applications. In this episode, we explore: The four standard isolation levels and their implications for data consistency A real-world e-commerce scenario illustrating the importance of choosing the right isolation level Performance t…

1
Event Sourcing in Distributed Systems: Deep Dive into Benefits, Challenges, and Implementation 17:15

4M ago17:15

17:15

Dive into the world of Event Sourcing and discover how this powerful architectural pattern can revolutionize your distributed systems. In this episode, we explore: The core concept of Event Sourcing and its game-changing benefits (SCALE) A real-world application in financial systems that showcases Event Sourcing's true potential Key implementation …

1
#068 - Should you trust tech influencers? feat. Charles The III 1:12:50

4M ago1:12:50

1:12:50

Today we welcome Chuck Carpenter aka Charles The 3rd, co-host at Whiskey Web and Whatnot. As two content creators in the tech scene, we discuss if and how celebrity developers and tech influencers are a good thing for the community, how we should be careful when choosing technologies based on influencers’ opinions, why so many people nowadays want …

1
Running out of TCP ephemeral source ports 20:06

4M ago20:06

20:06

In this episode of the backend engineering show I describe an interesting bug I ran into where the web server ran out of ephemeral ports causing the system to halt. 0:00 Intro 0:30 System architecture 2:20 The behavior of the bug 4:00 Backend Troubleshooting 7:00 The cause 15:30 Ephemeral ports on loopback…

1
Database Indexing Explained: Clustered vs. Non-Clustered Indexes for Performance Boost 6:16

4M ago6:16

6:16

Dive into the world of database indexing and discover how it can significantly boost your database performance. In this episode, we explore: The fundamentals of database indexing and its role in speeding up data retrieval Clustered vs. non-clustered indexes: Understanding their differences and use cases How indexing impacts database performance, in…

1
Demystifying ISA: Understanding Instruction Set Architecture 7:14

4M ago7:14

7:14

Dive into the world of Instruction Set Architecture (ISA) with our expert guest, Victor, as we unpack this crucial concept for senior backend engineers. In this episode, we explore: ISA basics: Uncover the fundamental components that bridge hardware and software CISC vs. RISC vs. MISC: Compare different ISA types and their real-world applications A…

1
Demystifying Syntax Analysis: An Essential Guide to Parsing in Programming 6:00

4M ago6:00

6:00

Dive into the world of compiler design with our expert guide to syntax analysis, an essential component of programming language processing. In this episode, we explore: The fundamentals of syntax analysis and its crucial role in the compilation process Parse trees and Abstract Syntax Trees (ASTs): Decoding program structure Top-down vs bottom-up pa…

1
Pods vs. Containers: Understanding the Difference in Cloud Computing 7:58

4M ago7:58

7:58

Dive into the world of Kubernetes as we unravel the differences between Pods and Containers, essential concepts for any cloud computing professional. In this episode, we explore: Pods vs. Containers: Definitions, scope, and key differences Crucial characteristics of Pods in Kubernetes and their importance How Kubernetes orchestrates multiple contai…

1
Demystifying SLIs and SLOs: A Guide to Service Level Indicators and Objectives 8:08

4M ago8:08

8:08

Dive into the world of Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with our expert guest, Victor, as we unravel these crucial concepts in Software Reliability Engineering. In this episode, we explore: The definitions and importance of SLIs and SLOs in measuring service reliability Real-world examples of common SLIs and strat…

1
Building Resilient Systems: Strategies for High Availability and Fault Tolerance 8:24

4M ago8:24

8:24

Dive into the world of resilient system design with expert insights on ensuring high availability and fault tolerance. In this episode, we explore: Fundamental strategies for robust systems, including redundancy, load balancing, and active-active vs. active-passive setups Geographical distribution and data consistency challenges in distributed syst…

1
Demystifying Design Patterns: Factory vs. Abstract Factory Explained 6:55

4M ago6:55

6:55

Explore the nuances of two crucial design patterns in object-oriented programming with expert insights from experienced software engineer Victor. In this episode, we explore: The core concepts of Factory and Abstract Factory patterns Real-world examples using a pizza ordering system Implementation strategies and scalability challenges Key differenc…

1
NoSQL vs. Relational: Making the Right Database Selection for Your Project 9:07

4M ago9:07

9:07

Dive into the crucial decision-making process of selecting the right database for your project with expert insights from experienced backend engineer Victor. In this episode, we explore: Key differences between NoSQL and relational databases, unraveling their strengths and weaknesses Critical factors to consider when choosing a database, from data …

1
Demystifying Database Normalization: Understanding 1NF, 2NF, and 3NF 7:02

4M ago7:02

7:02

Dive into the world of database normalization with expert insights on 1NF, 2NF, and 3NF. In this episode, we explore: The fundamentals of database normalization and its importance in modern systems Breaking down the First, Second, and Third Normal Forms with clear explanations Real-world examples that illustrate how to apply normalization principle…

1
ZeroMQ vs RabbitMQ: Choosing the Right Tool for Your Messaging Use Cases 10:54

4M ago10:54

10:54

Dive into the world of messaging technologies as we compare ZeroMQ and RabbitMQ in this insightful episode of Technology Comparisons Interview Crashcasts. In this episode, we explore: The key differences between ZeroMQ's lightweight library and RabbitMQ's full-featured broker Ideal use cases for each technology, from real-time systems to enterprise…

1
Demystifying System Calls: The Bridge Between Programs and Operating Systems 6:38

4M ago6:38

6:38

Dive into the world of system calls and uncover their crucial role in bridging the gap between user applications and operating systems. In this episode, we explore: The fundamentals of system calls and their importance in modern operating systems A step-by-step breakdown of how system calls work, from user space to kernel space and back Performance…

1
Demystifying the TCP Three-Way Handshake: Understanding Network Connections 7:14

4M ago7:14

7:14

Dive into the world of network connections as we demystify the TCP Three-Way Handshake process, a crucial concept for aspiring backend engineers. In this episode, we explore: The three steps of the handshake: SYN, SYN-ACK, and ACK The critical role of sequence numbers in maintaining data transmission order Potential issues and security concerns, in…

1
Demystifying Virtual Memory: Benefits and Workings Explained 5:58

4M ago5:58

5:58

Dive into the world of virtual memory and uncover its inner workings and advantages for modern computing systems. In this episode, we explore: Understanding virtual memory: definition and core concepts Key benefits and why they matter for programmers The mechanics behind virtual memory: pages, tables, and buffers Advanced memory management techniqu…

1
Kotlin Data Classes vs. Regular Classes: Understanding the Difference 5:36

4M ago5:36

5:36

Dive into the world of Kotlin as we explore the crucial differences between data classes and regular classes in this information-packed episode of "Kotlin Internals Interview Crashcasts"! In this episode, we explore: The purpose and efficiency of data classes as streamlined data containers Automatically generated utility functions that make data cl…

1
Unveiling Kafka's High-Performance Mechanisms: The Secret to Throughput and Latency 7:31

4M ago7:31

7:31

Dive into the inner workings of Kafka and discover how it achieves impressive performance in handling massive data streams. In this episode, we explore: Kafka's distributed architecture and commit logs Disk and network optimizations for enhanced throughput Scalability through intelligent partitioning Efficient data consumption with consumer groups …

1
Breaking Down the JVM: Understanding Its Core Components 7:57

4M ago7:57

7:57

Dive into the intricate world of Java Virtual Machine (JVM) internals with expert insights from experienced Java developer Victor. In this episode, we explore: The three core components of the JVM: Class Loader, Runtime Data Area, and Execution Engine A deep dive into the Runtime Data Area, including Method Area, Heap, Java Stacks, and more The Exe…

1
Java Garbage Collection Demystified: Algorithms, Minor vs Major GC, and Performance Boosts 7:15

4M ago7:15

7:15

Dive into the world of Java garbage collection with our expert guest, Victor, as we unravel the mysteries behind memory management in Java. In this episode, we explore: Garbage collection algorithms and strategies, including Mark-and-Sweep, Copying, and Mark-Compact Minor vs Major GC: Understanding the differences and their impact on performance Ge…

1
Unlocking the Power of Message Queues in Distributed Systems 9:40

4M ago9:40

9:40

Dive into the world of message queues and their crucial role in distributed systems with our expert guest, Victor. In this episode, we explore: The core purpose of message queues and their game-changing benefits in distributed systems Essential features and implementation challenges that every developer should know Advanced topics like scalability …

1
Database Normalization Explained: Understanding 1NF, 2NF, 3NF, and BCNF 8:12

4M ago8:12

8:12

Dive into the world of database organization with our comprehensive guide to normalization and its various forms. In this episode, we explore: The fundamentals of database normalization and why it matters A step-by-step journey through normal forms: from 1NF to BCNF Real-world applications and when to break the rules Tune in for expert insights on …

1
Computer Architecture vs. Organization: Demystifying the Difference 9:28

4M ago9:28

9:28

Dive into the crucial distinction between computer architecture and organization, essential knowledge for senior backend engineers. In this episode, we explore: The fundamental differences between conceptual design and hardware implementation How architecture and organization impact system performance and efficiency Real-world challenges and trade-…

1
Demystifying Lexical Analysis: Compiler Design Essentials 8:15

4M ago8:15

8:15

Dive into the world of compiler design with our expert-led exploration of lexical analysis, a crucial first step in understanding how programming languages are processed. In this episode, we explore: The fundamentals of lexical analysis and its role in compilation How source code is transformed into meaningful tokens Challenges in token recognition…

1
Kubernetes Architecture Explained: Master and Worker Nodes Demystified 5:53

4M ago5:53

5:53

Dive into the core of Kubernetes as we unravel the intricate architecture of Master and Worker nodes in this enlightening episode of "Kubernetes Interview Crashcasts". In this episode, we explore: The fundamental components of Kubernetes architecture and their roles Master node's brain: API server, etcd, scheduler, and controller manager unveiled W…

1
Understanding Error Budgets: A Key SRE Practice for Managing System Reliability 7:06

4M ago7:06

7:06

Dive into the world of Site Reliability Engineering (SRE) and explore the critical concept of error budgets with host Sheila and experienced SRE professional Victor. In this episode, we explore: The fundamentals of error budgets and their calculation in relation to Service Level Objectives (SLOs) How SRE teams use error budgets to balance innovatio…

1
Microservices vs. Monolithic Architecture: Pros and Cons for Modern Software Design 6:00

4M ago6:00

6:00

Dive into the world of modern software architecture as we explore the crucial debate between microservices and monolithic design in this must-listen episode for aspiring senior backend engineers. In this episode, we explore: The fundamental differences between microservices and monolithic architectures Key advantages of microservices, including sca…

Podcaster verdt å lytte til

Backend Podcaster

Podcaster verdt å lytte til

Hurtigreferanseguide