This series provides a comprehensive guide based on the ISTQB Foundation Syllabus v4.0 (2023), specifically designed to help candidates prepare for the Certified Tester Foundation Level (CTFL) qualification. Authored by experts Erik van Veenendaal, Rex Black, and Dorothy Graham, the content explores software testing fundamentals, the Software Development Life Cycle (SDLC), and modern methodologies such as Agile and DevOps. Listeners will learn to apply seven core testing principles, perform static testing through reviews, and utilise various test design techniques, including black-box, white-box, and experience-based approaches. Additionally, the series covers test management strategies like risk-based testing, test planning, and the evaluation of test automation tools. Ultimately, the goal of this resource is to promote testing as an essential software engineering discipline while helping professionals deliver high-quality products

This episode examines the "intimidating" and "vague" world of system design interviews, where processes are often open-ended and lack a single correct answer. Drawing on the expertise of Alex Xu, an experienced software engineer who has worked at Apple and Twitter, the discussion explores how to transform broad technical problems into scalable architectures

In this episode, we explore the core tenets of John Ousterhout’s seminal work, A Philosophy of Software Design. Software engineering is one of the purest creative activities in history, yet its greatest limitation is our ability to understand the systems we create. As programs evolve, complexity accumulates, making it harder and more expensive to maintain them.We break down how to fight this "incremental enemy" by shifting your mindset and refining your technical approach.What you will learn in this overview:• The Strategic Mindset: Why "working code isn't enough" and how to transition from tactical programming (quick fixes) to strategic programming (investing in long-term design).• Deep vs. Shallow Modules: The secret to powerful abstractions. We discuss how the best modules provide significant functionality through simple interfaces, using the Unix I/O and garbage collection as prime examples.• Information Hiding: How to encapsulate design decisions within a module to reduce cognitive load and prevent information leakage across your system.• Defining Errors Out of Existence: A philosophical shift in exception handling. Learn how to design APIs so that special cases are handled naturally by the normal flow, reducing clunky try-catch boilerplate.• Documentation as a Design Tool: Why you should write comments first. We explain how describing an abstraction before coding it acts as a "canary in the coal mine" for complexity.• Precise Naming: Why a single poorly chosen variable name can cause six months of debugging, and how to create a clear mental image for the reader.About the Source: This overview is based on the book A Philosophy of Software Design (2018) by John Ousterhout, a Professor of Computer Science at Stanford University and the creator of the Tcl scripting language

In this episode, we dive into the fundamental principles for building software systems that are reliable, scalable, and maintainable. We move past industry buzzwords to gain a technically precise understanding of the various technologies and trade-offs involved in modern data processing.We explore the transition from compute-intensive to data-intensive applications, where the primary challenges are the quantity, complexity, and speed of change of data. The discussion covers the evolution of data models, comparing the traditional relational model with the more recent document and graph models, and how these choices affect the way we think about the problems we solve.Listeners will gain insights into the internals of storage engines, including the differences between log-structured merge-trees (LSM-trees) and B-trees, as well as the distinction between transactional (OLTP) and analytic (OLAP) workloads. We also address the intricate challenges of distributed data, such as the trade-offs in synchronous versus asynchronous replication, the necessity of partitioning (sharding) for scalability, and the foundational role of consensus in achieving fault tolerance.Finally, we examine how to integrate these systems using batch and stream processing to create derived data, such as search indexes and caches, ensuring your application architecture remains robust as it grows.

Understanding these complex systems is like building with a garden hose: while you can screw different segments together to massage data in new ways, you must ensure the underlying plumbing is strong enough to handle the pressure without springing a leak.

This podcast delves into the fundamental design considerations for Enterprise Applications, which typically involve the display, manipulation, and storage of large amounts of often complex data and the support or automation of business processes. These systems are often characterised by complex data and voluminous records, alongside business rules (or "illogic") resulting from various special cases,. We explore architectural patterns that capture proven design ideas for tackling the inherent complexity of building and maintaining these systems

This podcast focuses on two indispensable practices for effectively documenting and governing critical architectural decisions: Architectural Decision Records (ADRs) and Architecture Fitness Functions.

Join us as we explore the latest advancements, including Google's innovative Titans architecture, designed to handle vast amounts of data and long-range dependencies

●Drawing on insights from the book Software Engineering at Google, each episode will cover key aspects of Google's engineering culture, processes, and tools.

●Learn how Google engineers tackle issues like time, scale, trade-offs, knowledge sharing, testing, and documentation.

●Discover the importance of building sustainable code, fostering strong teams, and embracing diversity and inclusivity in engineering practices.

●Whether you're a seasoned software engineer or just starting out, this podcast offers valuable insights into building better software and creating a positive engineering culture

- We will start with the fundamentals, such as data models and query languages, and then move on to more advanced topics, such as replication, partitioning, transaction processing, and distributed consensus.

- Along the way, we will examine real-world examples and discuss the trade-offs involved in different design decisions