Conversations about Software Engineering (CaSE) is an interview podcast for software developers and architects about Software Engineering and related topics. We release a new episode every three weeks.

CaSE: Conversations about Software Engineering

https://images.podigee-cdn.net/0x,s4gbIsFSYAj2BO2hCuw_w2Hd2dkwbiJZ44UvGZNvcy5E=/https://cdn.podigee.com/uploads/u861/CaSE-logo1485898745be6c.png

Alex Bramley talks to Sven Johann about the basics of service level objectives. They begin with terminologies (SLI, SLO, SLA, Error Budget), look at costs of outages and discuss what reliability has to do with customer happiness. They continue with having 100% reliability is the wrong target and what’s possibly the right target. Alex then explains how to get started with collecting data about your system’s behaviour. They close the first part of this series by looking into latency SLIs.

Alex Bramley talks to Sven Johann about the basics of service level objectives

https://www.case-podcast.org/40-alex-bramley-on-the-art-of-slo-part-1

Simon Brown talks to Stefan Tilkov about software architecture – the importance for developers, its role in agile software development, documentation and tooling, and the importance (or lack of importance) of UML.

https://www.case-podcast.org/39-simon-brown-on-software-architecture

Eoin Woods discusses with Sven Johann all the things developers need to know to bring systems successfully into production and how to keep them there. They discuss production environments, what goes wrong in production, architectural requirements for operations, cost of very high availability, stability and capacity, communicating operational concerns, observability, learning from incidents, chaos engineering and operational models (SRE, You build it, you run it, classic).

sre,production,observability,chaos engineering

Eoin Woods on Bringing Systems into Production and Keeping them there

https://www.case-podcast.org/38-eoin-woods-on-bringing-systems-into-production-and-keeping-them-there

In this episode, Stefan talks to software developer Christin Gorman about her experience with very large software projects and the reasons why they fail, especially in the public sector. The two address issues of size, approaches that do and don’t work, share some of their favorite failure stories and try to enumerate some strategies to do something about them.

Christin Gorman on Why large projects fail and what to do about it

https://www.case-podcast.org/37-christin-gorman-on-why-large-projects-fail-and-what-to-do-about-it

In this episode, Artur Ortega explains to Stefan Tilkov what GraphQL is, how it came to be, and how it differs from REST. Predictably, the two debate whether it’s better or not, but also spend some time going over its technical details and applicability to different usage scenarios.

Stefan Tilkov talks with Artur Ortega about GraphQL

https://www.case-podcast.org/36-artur-ortega-on-graphql

In this episode, Markus Völter talks with Stefan Tilkov about language engineering and its connection to domain-driven design. Picking up from their past interactions in various different podcasts, the two agree and disagree fundamentally in equal parts, on topics such as the usefulness of DSLs, the costs and benefits of domain experts writing code, and the tradeoffs of various architectural approaches.

language engineering,domain-driven design,dsl

Stefan Tilkov talks with Markus Völter about language engineering

https://www.case-podcast.org/35-markus-volter-on-language-engineering

Birgitta Böckeler talks with Sven Johann about cultivating architecture principles. They first discuss what architecture principles are, why they are useful, how they are structured and how they help to guide decision making across multiple teams. They then talk about their lifecycle: who creates them, checks if they are aligned with business goals, prioritizes them, how they should be communicated, how you know they are useful and when to potentially retire them.

Sven Johann talks with Birgitta Böckeler about Cultivating Architecture Principles

Birgitta Böckeler on Cultivating Architecture Principles

https://www.case-podcast.org/34-birgitta-bockeler-on-cultivating-architecture-principles

Joy Heron talks with Rachel Andrew about CSS Layout. Rachel shares her journey as a web developer and how the web has changed over that time. They discuss Rachel’s work with the CSS working group and how developers can get involved to improve the web for the future. Rachel also talks about the current status of CSS layout and what we can expect in the near future. To wrap up, Rachel shares some practical tips and they discuss the future of the web platform.

css,css layout,css working group,w3c,web development,html,css grid,flexbox,multi-column spec,accessibility

Joy Heron interviews Rachel Andrew about CSS

Rachel Andrew on contributing to CSS and CSS Layout

https://www.case-podcast.org/33-rachel-andrew-on-contributing-to-css-and-css-layout

Daniel Bryant talks with Sven Johann about the business problems to modernize applications. They need to be decoupled from the compute fabric and the network fabric and Daniel explains the reasons for that, what products are available and what strategies the different cloud vendors follow. They move on with how to get started, questions to select an API gateway, technologies behind them and the challenges. They talk about service meshes features, especially on the canary testing side, how they work under the hood and how they help as infrastructure with application modernization. They close the discussion on how to select a service mesh product and what rollout strategies exist.

architecture,cloud,cloud native,service mesh,api gateway,microservices

Sven Johann talks with Daniel Bryant about Service Meshes & API Gateways

Daniel Bryant on Service Meshes and API Gateways for Application Modernization

https://www.case-podcast.org/32-daniel-bryant-on-service-meshes-and-api-gateways-for-application-modernization

Does functional programming matter? Stefan and Mike continue an interesting conversation they had on Twitter: Does the style of programming matter if you look at it from a larger distance? Mike describes two distinguishing characteristics of functional programming: Immutable data and high-level models, and how they influence the architecture of your application.

functional programming,algebra,domain driven design,modeling

Stefan Tilkov talks with Mike Sperber about Functional Architecture

https://www.case-podcast.org/31-mike-sperber-on-functional-architecture

Peter Elger talks with Sven Johann about AI as a service - commodity web services offered by large cloud providers, which make it very easy to use AI in your application just by using an API. They start the discussion with the typical AI use cases companies in finance, retail and so on have and which of those are already as a commodity available and which are not. They then discuss how those APIs are used, from very simple API calls like text-to-speech to slightly more complicated ones like chat bots or recommendation engines. They continue with understanding how you come up with AI requirements and how to (regression) test your AI service, which is often different than doing the same with non-AI code. They clarify how much AI you need to know to use those services, the cost models of them and how to get your AI to production. The conversation then moves to lower level AI services like AWS SageMaker or Google Tensorflow and how you combine them to create novel pieces of AI relatively quickly. They close the conversation with when to use specific packaged AI solutions and when to create your own AI to push the envelope.

Sven Johann talks with Peter Elger about Commodity AI

https://www.case-podcast.org/30-peter-elger-on-commodity-ai

In this episode of the CaSE podcast, Lucas talks to Lars Hupel of Typelevel-fame about algebraic design. Lars starts to explain how the expression problem views the difference between the functional and Object Oriented style of programming. He then explains the concept of an algebra – from coupling trains to CRDTs. This leads to a discussion on comprehensive and iterative thinking styles and how different styles of testing and proving work. Finally, they bring it all back to type systems.

algebra,programming,functional programming,proof systems,scala

Lucas Dohmen talks with Lars Hupel about Algebraic Design

https://www.case-podcast.org/29-lars-hupel-on-algebraic-design

In this Conversation about Software Engineering, Stefan Tilkov talks with Ryan Singer about Shape Up. Ryan works on the product strategy for Basecamp. Over time the company started growing, and they needed to step up how they managed their product development work. In his book Shape Up and this podcast, Ryan shares the methodology Basecamp uses nowadays.

Stefan Tilkov talks with Ryan Singer about Shape Up

https://www.case-podcast.org/28-ryan-singer-on-shape-up

In this episode, Stefan Tilkov talks with Felienne Hermans, associate Professor at Leiden University in the Netherlands heading the Programming Education Research Lab. They talk about programming education with a focus on people learning their first programming skills and how the current approach in schools and university is flawed. Felienne explains the concept of deliberate practice and code vocalization and answers simple questions like "What's the best programming language for education?"

Stefan Tilkov talks with Felienne Hermans about Programming Education

Felienne Hermans on Programming Education

https://www.case-podcast.org/27-felienne-hermans-on-programming-education

In this episode, Sven Johann hosts Philippe Kruchten, the author of the Managing Technical Debt book. They talk about the research leading to the book and the practical implications the book and the research offer. They start the conversation with discussing terms: technical debt, interest, principal and then start with technical debt on the code level, e.g. code smells, tests and refactoring followed by static analysis and the prioritization of the findings. They then move to technical debt on the architectural level and go through the possibilities on estimating cost and value on those improvement and how to sell it to the business stakeholders. This is followed by explaining technical debt on the infrastructure level and how great code can become technical debt by time passing by (technological gap, software aging). After that the conversation moves towards solving the problem tactically and strategically.

software architecture,technical debt,evolution

Sven Johann talks with Philippe Kruchten about Managing Technical Debt

Philippe Kruchten on Managing Technical Debt

https://www.case-podcast.org/26-philippe-kruchten-on-managing-technical-debt

In this episode, Sven Johann hosts Sam Newman, the author of the first Microservices book, to talk about security in the world of Microservices. They discuss why and where it is different to security in a monolithic architecture and why developers must care. They start with automatically rolling out passwords, credentials and API keys in a secure way and continue with patching containers and secure base images. They then continue with  automatically update (transitive) dependencies if they have vulnerabilities. They close the conversation with discussing authorisation and authentication using gateways, proxies and service meshes.

distributed systems,security,microservices,service mesh

Sven Johann talks with Sam Newman about Microservices Security

Sam Newman on Insecure Transit – Microservices Security

https://www.case-podcast.org/25-sam-newman-on-insecure-transit

In this episode, Stefan Tilkov talks to author and microservices expert Richard Rodger about his approach to microservices, which focuses on small services that exchange messages, are built using a “generalize first” approach, and rely on content-based routing to allow for dynamic evolution of the resulting system.

microservices,architecture,software engineering

Stefan Tilkov talks with Richard Rodger about message-based, generic microservices

Richard Rodger on Message-based, Generic Microservices

https://www.case-podcast.org/24-richard-rodger-on-microservices

In this episode, Stefan Tilkov hosts well-known distributed systems expert Steve Vinoski to talk about lessons learned in 30+ years of software engineering. In their conversation, they cover topics such as what to learn and what to avoid, how to deal with zealous and disillusioned developers, the relation of engineering to other disciplines, ethics and patents, careers and coding, publishing and presenting and the benefits of doing maintenance. 

Steve Vinoski has spent most of his software development career working in the areas of middleware and distributed computing systems, using C++ and Erlang. He is also a long-time author, having written or co-authored over 100 published articles and papers covering middleware, distributed systems, and web development, as well as a couple books and dozens of columns. Steve has also given hundreds of conference and workshop presentations and tutorials on middleware, distributed systems, web development, and programming languages, and has served as chair or program committee member for many dozens of conferences and workshops.

software engineering,learning,mentoring,ethics,patents

Stefan Tilkov talks with Steve Vinoski about Mentoring Engineers

https://www.case-podcast.org/23-mentoring-engineers-with-steve-vinoski

In this conversation about software engineering, Gustaf Nilsson Kotte, web architect at IKEA, talks to host Stefan Tilkov about ways to build large web sites and applications with multiple teams. Topics covered include team organization and Conway’s law, horizontal vs. vertical splits, and options and tools for server-side and client-side integration.

web,web development,microfrontends,frontend

Stefan Tilkov talks with Gustaf Nilsson Kotte about Micro Frontends

Micro Frontends with Gustaf Nilsson Kotte

https://www.case-podcast.org/22-micro-frontends-with-gustaf-nilsson-kotte

Joy Clark talks with Lucas Dohmen about Web Front-End development. They first discuss the role of front-end development and frontend architecture. Lucas then explains his view on the role of JavaScript and the separation between front-end and back-end development. They continue their discussion by looking at the role of design and UX in front-end development and how styleguides can help. Then Lucas talks about performance, development for mobile devices and accessibility. They wrap up by discussing tooling and the faucet-pipeline.

Joy Clark Talks with Lucas Dohmen about Web Front-end Development

https://www.case-podcast.org/21-web-frontend-with-lucas-dohmen

Joy Clark talks with Rich Hickey about Clojure and Datomic and the reasons that Rich decided to design them the way that he did. They discuss the dependency problem and how we should change our method of developing libraries so that we do not introduce breaking changes. Rich also introduces Clojure spec and describes what it can be used for and how it differs from a static type system. To wrap up the episode, they talk about the best way to solve a problem (and know it is the right problem!) and Rich gives some advice on how to develop software and what technologies are worth looking into.

clojure,datomic,software engineering,clojure script,problem solving

Joy Clark talks with Rich Hickey about Clojure and Datomic

Problem Solving and Clojure 1.9 with Rich Hickey

https://www.case-podcast.org/20-problem-solving-and-clojure-19-with-rich-hickey

Sven Johann talks with Susan Landau about Security and Privacy. After defining those terms they proceed to find out why this important to individuals and societies. They discuss why its the job of intelligence agencies to collect data, but how we can protect us against them. Then Susan discusses the importance of Two-Factor Authentication, how wiretapping and backdoors work these days and how the FBI tries to unlock locked devices with “1984” terminology. The conversation moves from end-to-end encryption, metadata analysis and VOIP decryption to targeted attacks and political influence of security threats. They finish the conversation with what we can learn from Google and Sun Microsystems on privacy, security and the architectural requirements of anonymized test data.

Sven Johann talks with Susan Landau about Security and Privacy

https://www.case-podcast.org/19-security-and-privacy-with-susan-landau

Joy Clark talks with Peter Chestna about application security. The overarching topic of the podcast was what a developer can do in order to make applications more secure. This included talking about some of the most prevalent security vulnerabilities and discussing what application security is and what it entails. Peter also gave some great tips on how to integrate security into the development process.

Joy Clark talks with Peter Chestna about application security

https://www.case-podcast.org/18-application-security

In this second episode of a two-part interview, Stefan Tilkov talks to Bitcoin and cryptocurrency expert Andreas M. Antonopoulos about Bitcoin vs. blockchain tech, the programmable Ethereum system, alternatives to the proof of work approach, and using Bitcoin in hybrid scenarios.

Stefan talks with Andreas M. Antonopoulos about Ethereum

Blockchain Technology with Andreas M. Antonopoulos (Part 2)

https://www.case-podcast.org/17-blockchain-technology-with-andreas-m-antonopoulos-part-2

In the first episode of a two-part interview, Stefan Tilkov talks to Bitcoin and cryptocurrency expert Andreas M. Antonopoulos about the Bitcoin system’s technical foundation and architecture. Andreas addresses common questions about Bitcoin’s usefulness, scalability, and energy consumption.

Stefan talks with Andreas M. Antonopoulos about Bitcoin

Blockchain Technology with Andreas M. Antonopoulos (Part 1)

Joy talks with Vaughn Vernon about Domain-Driven Design. Vaughn shares his journey to DDD and the reasons behind his DDD books. They then go on to discuss strategic design, the broad brush strokes of DDD, what a model actually looks like and how to use bounded contexts to keep a system from becoming a big ball of mud. Vaughn then answers some questions about domain events and event sourcing, and makes a case for modelling uncertainty instead of fighting with concurrency.

domain-driven design,domain event,event sourcing,ddd,strategic design

Joy talks with Vaughn Vernon about Domain-Driven Design

https://www.case-podcast.org/15-domain-driven-design-with-vaughn-vernon

Joy Clark talks with Gernot Starke about aim42, a method for systematically improving software. They discuss in detail the three phases of the process: Analyze, Evaluate, and Improve. Gernot shares his wisdom about how to carry out each phase using stories of his experiences in many different situations. In this way, listeners will get the big picture of how the whole process works: from visualizing all of the problems using sticky notes on the wall to specific strategies that can be used for improving the system.

Joy Clark interviews Gernot Starke about aim42

https://www.case-podcast.org/14-aim42-with-gernot-starke

Daniel Westheide, author of “The Neophyte’s guide to Scala” and Stefan Tilkov  talk about some advanced Scala features and challenges, such as case classes and the problems they can create, algebraic data types, type classes and implicits, using the compiler for Prolog-like type level programming and programming with generic data structures.

Scala,JVM,Software Engineering,Programming

Stefan Tilkov interviews Daniel Westheide about advanced Scala Topics

https://www.case-podcast.org/13-advanced-scala-with-daniel-westheide

Joy Clark talks with David Nolen about ClojureScript. David introduces the language and discusses the direction that the language is heading in. He talks about how the language is compiled to JavaScript and how it takes advantage of the the Google Closure Compiler. They then talk about designing user interfaces and how functional programming relates to UI design. To wrap up, David mentions different libraries and frameworks that can be used and recommends tools which can be used to get started programming with ClojureScript.

ClojureScript,Clojure,Functional Programming,Frontend,React

Joy Clark interviews David Nolen about ClojureScript

https://www.case-podcast.org/12-clojurescript-with-david-nolen

Stefan Tilkov talks to Camille Fournier about making a career as a manager in a software development organization. Camille shares her insights about when or why someone would want to become a manager and how to become good at it. Other topics include different levels of management from tech lead to CTO, the role of one-on-one meetings, and how managers influence company culture.

Management,Career,Engineer,Tech Lead,Manager,CTO,One-on-ones

Stefan Tilkov interviews Camille Fournier about Management for Developers

Management for Developers with Camille Fournier

https://www.case-podcast.org/11-management-for-developers-with-camille-fournier

Joy Clark talks with Sofia Vaughn-Jones (née Cole) about Scala. Sofia introduces the language and describes its features. They then discuss what kinds of programs can be written with Scala and the tooling and frameworks that are available. They attempt to define what a monad is and how it can be used. To wrap up, Sofia mentions some great resources for getting started with Scala.

scala,programming languages,learning,monads

Joy Clark talks with Sofia Vaughn-Jones about Scala

https://www.case-podcast.org/10-scale-with-sofia-vaughn-jones

In this episode, Stefan Tilkov talks to Michele Leroux Bustamante about Microservices. Michele shares her perspective on microservices and what she sees as the difference between SOA and microservices: The way they share data. Stefan and Michele also talk about orchestration, getting started with microservices, platforms for microservices as well as a few short other topics.

microservices,domain driven design,cqrs,docker

Stefan Tilkov talks with Michele Bustamante about Microservices

Microservices with Michele Leroux Bustamante

https://www.case-podcast.org/9-microservices-with-michele-leroux-bustamante

Joy Clark talks with Alex Miller about Clojure. Topics include the Clojure language and how it compares to other languages as far as features and maintainability are concerned. The benefits of dynamic languages are also discussed, and clojure.spec is introduced as a way to gain the benefits of statically typed languages. Alex also talks about ways to structure Clojure code and gives a great list of tools and materials for getting started with Clojure.

Clojure,ClojureScript,Functional Programming,Dynamic Programming,REPL,Lisp,Programming Languages

Joy Clark talks with Alex Miller about Clojure

https://www.case-podcast.org/8-clojure-with-alex-miller

Lucas Dohmen talks with Eberhard Wolff about microservices. Eberhard Wolff is a fellow at innoQ and wrote a book as well as a primer about microservices. He talks about what lead to microservices and the advantages, and disadvantages of as well as the preconditions for the architecture. He then introduces different styles of microservices and how they influence and are influenced by organizational structures. Eberhard also talks about introducing microservices, how they communicate with each other as well as testing microservices.

Lucas Dohmen talks with Eberhard Wolff about microservices

https://www.case-podcast.org/7-microservices-with-eberhard-wolff

Eberhard Wolff talks with Ute Mayer about Rails Girls. Topics include how Rails Girls increase diversity in IT and thereby influence the live of the attendees. Rails Girls is a global movement and does workshops to introduce women to programming. Attendees can then join project groups to work on specific projects and apply for the Rails Girls Summer of Code to develop open source projects. The training material is free and open source - and includes information how to start a Rails Girls group. There are many way to support: Rails Girls is looking for coaches and sponsors.

Eberhard Wolff talks with Ute Mayer about Rails Girls

https://www.case-podcast.org/6-rails-girls-with-ute-mayer

Joy Clark talks with Chad Fowler about legacy software and immutable infrastructure. They begin by discussing legacy software and why the description 'legacy' shouldn't actually be a bad thing. Then they contrast how reusable libraries differ from a system of services which is flexible and can change over time. Chad then describes how they developed Wunderlist using a microservices architecture and answers questions about how to practically develop and test such a system and how to decrease coupling between components. They wrap up by discussing how the principles of immutable infrastructure can be applied to software development in general.

Legacy software,immutable architecture,Docker,microservices,aws

Joy Clark talks with Chad Fowler about legacy software and immutable architecture

Legacy Software and Immutable Infrastructure with Chad Fowler

https://www.case-podcast.org/5-legacy-software-and-immutable-infrastructure-with-chad-fowler

Joy Clark talks with Stefan Tilkov about software architecture. After discussing the definition of software architecture, they go on to cover what the role 'Software Architect' actually means and what tools and skills an architect needs to do their job. They also discuss several different architectural styles which can be used and look at the most common styles that are currently employed today. To help us on our quest to becoming software architects, Stefan also gives a great lists of resources that we can use as a starting point.

Joy Clark talks with Stefan Tilkov about software architecture

https://www.case-podcast.org/4-software-architecture

Eberhard Wolff talks with Martin Stadler about OpenTechSchool, an organization that helps people to learn about programming and software development. Topics include the different types of events and material OpenTechSchool offers and how OpenTechSchool enables a hands-on, empowering, and peer-driven approach. We also discuss the organization, the core values and how OpenTechSchool increases diversity. OpenTechSchool has a lot of partners and local chapters that take different approaches. Of course the show also talks about how to join OpenTechSchool, how to help and how to start your own chapter.

Eberhard Wolff talks with Martin Stadler about OpenTechSchool

https://www.case-podcast.org/3-open-tech-school

Eberhard Wolff talks with Oliver Gierke about Spring Data. The show starts with an overview of the Java framework Spring and its ecosystem. The focus of the show is Spring Data: A set of frameworks that support many different relational and NoSQL datastores. The show then discusses how Spring Data is developed and released. Another topic is how reactive programming influences persistence and how transactions make little sense for reactive architectures. Finally, the show covers Spring Data REST — a framework to expose Spring Data repositories as REST resources — and how this concept is useful beyond simple CRUD operations.

Java,Spring Data,Spring,Spring Data REST,REST

Eberhard Wolff talks with Oliver Gierke about Spring Data

https://www.case-podcast.org/2-spring-data-with-oliver-gierke

Stefan Tilkov talks to Jen Simmons about CSS, the standard for applying layout rules to HTML pages. Jen talks about the often misunderstood role of CSS in the Web stack, why it matters, and how it has grown ever more powerful over the course of time. Also included: Some discussion about why so many developers don’t like CSS and what to do about it, and new features coming to the CSS standard.

css,design,layout,frontend,grid layout,flex layout,web programming,HTML

Stefan Tilkov talks to Jen Simmons about CSS, the standard for applying layout rules to HTML pages.

https://www.case-podcast.org/1-modern-css-with-jen-simmons

software engineering,software architecture,programming

BasicCaSE: Conversations about Software Engineering

Choose an episode to create a shareable clip

Episodes