Software Engineering Radio - The Podcast for Professional Software Developers
708 episodes - English - Latest episode: 12 days ago - ★★★★ - 210 ratingsSoftware Engineering Radio is a podcast targeted at the professional software developer. The goal is to be a lasting educational resource, not a newscast. Every 10 days, a new episode is published that covers all topics software engineering. Episodes are either tutorials on a specific topic, or an interview with a well-known character from the software engineering world. All SE Radio episodes are original content — we do not record conferences or talks given in other venues. Each episode comprises two speakers to ensure a lively listening experience. SE Radio is an independent and non-commercial organization. All content is licensed under the Creative Commons 2.5 license.
Homepage Apple Podcasts Google Podcasts Overcast Castro Pocket Casts RSS feed
Episodes
Episode 107: Andrew Watson on the OMG
August 19, 2008 05:46 - 1 hour - 61.7 MBThis episode is a discussion with Andrew Watson, Technical Director of the Object Management Group. The episode is structured into five parts. We start with the history of the OMG and its early work. Then we look at the set of standards it has been (or is currently) working on. Next is a discussion of the standardization process used by the OMG, including the much-debated topic of compliance testing. We then look at OMG's relationship to other standards bodies (W3C, OASIS). Finally Andrew an...
Episode 106: Introduction to AOP
August 09, 2008 17:07 - 1 hour - 59.3 MBThis episode is a systematic introduction to Aspect Oriented Programming (in contrast to the interview with Gregor Kiczales). We discuss the fundamentals of AOP, define many of the relevant terms and also look at how and where AOP is used in practice, as well as at some current research trends.
Episode 105: Retrospectives with Linda Rising
July 30, 2008 08:57 - 1 hour - 67.4 MBIn this episode we're talking to Linda Rising about retrospectives. We start by defining what a retrospective is and discuss some of the logistics of making it work for software projects. We then look at the different phases of a retrospective. The main part then is a discussion about some of the practices or games that are used to facilitate the retrospective. We conclude the retrospective discussion with destroying some of the prejudices against it and the relationship to process improvemen...
Episode 104: Plugin Architectures
July 20, 2008 07:30 - 56 minutes - 51.6 MBIn this episode we talk with Klaus Marquardt about building systems out of plugins. After briefly introducing the concept of a plugin in contrast to modules and related software engineering concepts, we discuss different views on plugins and different ways of working with plugins for developing software. We are looking at plugins for embedded systems as well as large business systems, at how plugins change the working mode and team organization, and discuss the possibilities of why and when t...
Episode 103: 10 years of Agile Experiences
July 10, 2008 07:04 - 55 minutes - 50.5 MBIn this episode we're talking to Jens Coldewey about his experiences in 10 years of introducing agile techniques to project teams. We discuss real-world examples and the lessons learned and strategies derived from them.
Episode 102: Relational Databases
June 30, 2008 09:15 - 1 hour - 58.5 MBIn this espisode we take a closer look at relational database systems and the concepts behind them. We start by discussing the relational paradigm, its concepts and ramifications, and go on to architectural aspects.
Episode 101: Andreas Zeller on Debugging
June 20, 2008 09:18 - 34 minutes - 31.3 MBIn this episode we're talking to Andreas Zeller. about debugging. We started the discussion with an explanation of what debugging and how it works in principle. We then briefly discussed the relationship between debugging and testing. Next was the importance of the scientific method for debugging. We then looked as debugging as a search problem, leading to a discussion about delta debugging, the main topic of this discussion. We concluded the discussion by looking at the practical usability o...
Episode 100: Software in Space
June 10, 2008 12:24 - 36 minutes - 33.2 MBIn this episode we're talking to Hans-Joachim Popp, CIO at DLR about software in space. We start out by reviewing some well-known accidents of unmanned space flight that were caused by software faults and use this as a motivation to discuss how to avoid these in the future. We discuss culture, process, techniques and tools that DLR uses to create high-quality software for use in unmanned space systems.
Episode 99: Transactions
May 31, 2008 12:09 - 1 hour - 56 MBThis episode takes a close look at transactions from different angles, starting with their fundamental properties of Atomicity, Consistency, Isolation, Durability but also investigating advanced topics like distributed or business transactions.
Episode 98: Stefan Tilkov on REST
May 23, 2008 06:55 - 55 minutes - 51.2 MBIn this episode we discuss REST (Representational State Transfer) with Stefan Tilkov. We started out by discussing the 5 steps to REST: IDs, links, Standard Methods, multiple representations and stateless communication. We then looked at how to use HTTP for REST, and discussed about how to use it for Web Services. We then we discussed whether and how to use REST for enterprise applications, and not just for apps on the internet. We concluded the discussion with a couple of recommendations.
Episode 97: Interview Anders Hejlsberg
May 16, 2008 19:41 - 48 minutes - 44 MBIn this episode we have the pleasure of talking to Anders Hejlsberg, Chief Language Strategist at Microsoft. We started by discussing his more distant past, namely, his involvement with Turbo Pascal and Borland's Delphi. We then looked at the influences Delphi had on C# and how C# evolved from Delphi. In the next section we discussed a couple of general language design issues, among them components and checked vs. unchecked exceptions. Next, we discussed interesting issues about languages of ...
Episode 96: Interview Krzysztof Czarnecki
May 08, 2008 19:14 - 33 minutes - 30.2 MBThis episode is the long-awaited (and much requested) interview with Krzysztof Czarnecki, the author, together with Ulrich Eisenecker, of the book Generative Programming. In the interview we discussed the state of generative programming today and related it to model-driven development and DSLs. We then talked a little bit about product lines in general. We then discussed his current field of research, which currently focusses on framework-specific modeling languages and non-trivial roundtri...
Episode 95: The New Guardian.co.uk website with Matt Wall and Erik DoernenBurg
May 01, 2008 13:49 - 44 minutes - 40.5 MBIn this episode we talk to Matthew Wall (Guardian News and Media) and Erik Doernenburg (Thoughtworks) about their work on the new guardian.co.uk website. We discuss the challenge of scalability and interactivity, their use of Domain Driven Design, some of the technical building blocks as well as the approaches they use for performance measuring and scalability tuning.
Episode 94: Open Source Business Models with Dirk Riehle
April 23, 2008 20:56 - 1 hour - 58.4 MBIn this episode we're talking to Dirk Riehle about open source business models. We started looking at the way OS projects work and defined different kinds of open source projects. In the main part of the discussion we looked at various ways of how to make money with open source: consulting, support contracts, commercial variant of an open source project, etc. We then looked at the chances and risks of each of these approaches. The next part focused on different open source licenses and how th...
Episode 93: Lessons Learned From Architecture Reviews with Rebecca Wirfs-Brock
April 15, 2008 12:38 - 52 minutes - 47.7 MBIn this episode, Markus talks to Rebecca Wirfs-Brock on what she has learned from architecture reviews. This is a very complement to the earlier episode on architecture evaluation.
Episode 92: Introduction to Game Development
April 07, 2008 13:19 - 48 minutes - 44.8 MBIn this Episode, Arno talks with Oliver Jucknath about the art of writing computer games. A lot of myth is attached to this area of computing, and while a game technically is just another program, it is written in a different context than typical business applications. This is true at the code level, where aggressive optimization is a focus throughout development. It also applies at the team level, where collaboration between specialists is pronounced. And the business context is different a...
Episode 91: Kevlin Henney on C++
March 30, 2008 05:15 - 1 hour - 58.9 MBIn this episode, we talk with Kevlin Henney about the C++ programming language. We look at the history and the culture of the language, and how it went through several phases in its evolution. We also take a look at some of the special language features of C++ and their overall influence.
Episode 90: Product Line Engineering, Pt. 3, with Charles Krueger
March 22, 2008 11:31 - 36 minutes - 33.8 MBIn this episode Charles Krueger, a well-known member of the product line engineering community, talks about his long term experiences in the field. Charles is also the founder and CEO of a company that provides tooling for variability management and product derivation. Besides some clarifications on terms like product line architecture and reference architecture, you also learn what kind of preconditions need to exist before product line engineering can be applied successfully.
Episode 89: Joe Armstrong on Erlang
March 12, 2008 10:53 - 53 minutes - 48.8 MBIn this Episode we're talking about Erlang with its creator Joe Armstrong. We started by looking at the history of the Erlang language and why it is so relevant today. We then looked at Joe's approach to Concurrency Oriented Programming and its main ingredients: share nothing, lightweight concurrency and pure message passing. We also compared this to the classic shared memory approach to concurrency. We then looked at other interesting aspects of Erlang, such as its functional nature (and wh...
Episode 88: The Singularity Research OS with Galen Hunt
March 02, 2008 20:58 - 46 minutes - 42.7 MBIn this episode we talk to Galen Hunt about the Singularity research OS. Galen is the head of Microsoft's OS Research Group and, together with a team of about 30 other researches, has built Singularity. We started our discussion by covering the basics of Singularity: why it was designed, what the goals of the project are as well as some of the architectural foundations of Singularity: software isolated processes, contract-based channels and manifest-based programs. In this context we also l...
Episode 87: Software Components
February 21, 2008 20:06 - 59 minutes - 54.8 MBIn this episode, Michael and Markus talk about software components. We first looked at a couple of attempts at defining what a component is. We then provided our own definition that will be used in the rest of the episode. We then looked at the promises of component-based development: why are components useful? We then discussed some of the typical metadata components should specify to make them useful. We discussed to some extent typical variations in component models. The next topic was th...
Episode 86: Interview Dave Thomas
February 11, 2008 12:04 - 40 minutes - 36.8 MBThis episode is an interview with Dave Thomas (OTI Dave or Smalltalk Dave, not PragDave). We started our discussion with a look at the (non-)success of objects and components. We then discussed some history behine Eclipse and Dave's role in OTI. We then compared Smalltalk and Ruby and looked at the promises of small and powerful languages such as Lisp. We also discussed the role of (static) type systems and the role of tool support for languages. We then switched gears and looked at what is ...
Episode 85: Web Services with Olaf Zimmermann
February 01, 2008 20:45 - 51 minutes - 47.5 MBIn this Episode we're talking about Web Services with IBM's Olaf Zimmermann. We mainly focus on the WS-* stack. We also discuss a couple of SOA foundations and architectural decisions that need to be taken when building an SOA using Web Serivces. We also briefly mention the REST vs. WS-* debate.
Episode 84: Dick Gabriel on Lisp
January 22, 2008 17:50 - 1 hour - 55 MBIn this Episode we're talking with Dick Gabriel on Lisp. We started by looking at artificial intelligence as the historic context of Lisp, the goals AI tried to reach, and how Lisp was supposed to help reach those. We then discussed the language itself, starting with the Data As Program / Program As Data concept that is a foundation for Lisp. Then we discussed adding a meta-circular interpreter, programming as language development, and the blurred boundary between language and frameworks (b...
Episode 83: Jeff DeLuca on Feature Driven Development
January 12, 2008 20:58 - 39 minutes - 36.5 MBIn this episode we talk with Jeff DeLuca about Feature Driven Development (FDD). As one member of the agile methods family FDD is not so famous as Scrum or Extreme Programming but is becoming more and more popular, especially for situations where you have fixed price contracts. As the inventor of FDD Jeff gives short introduction to the method itself, talks about the basic ideas behind FDD and discusses with us how FDD relates to other members of the agile family.
Episode 82: Organization of Large Code Bases with Juergen Hoeller
January 02, 2008 17:02 - 50 minutes - 46.6 MBIn this episode Eberhard Wolff speaks with Jürgen Höller, the co-found of the Spring framework. Spring is a tremendously successful Java framework so they discuss the design of large frameworks and the issues that arise in the evolution. Jürgen explains the management of dependencies in the framework, how to structure such a framework, how to offer compatibility for the existing user base while evolving the framework and the role of metrics during development.
Episode 81: Interview Erich Gamma
December 23, 2007 18:37 - 41 minutes - 38.3 MBThis episode is a conversation with Erich Gamma. We covered the four things he is known for in chronological order. We started with design patterns and the Gang-of-Four book of which he is the lead author. We then looked at JUnit, the testing framework he coauthored with Kent Beck and how it introduced unit testing to the masses. The next topic is obviously Eclipse, where Erich and his lab in Zürich is responsible for the Java Development Tooling. We also briefly discussed The Eclipse Way, th...
Episode 80: OSGi with Peter Kriens and BJ Hargrave
December 13, 2007 07:03 - 45 minutes - 41.6 MBThis episode is about OSGi, the dynamic module system for Java. Our guests are Peter Kriens (OSGI's Technical Director) and BJ Hargrave (OSGI's CTO). We'll discuss what OSGi is all about and why and in which contexts it is useful. Additionally we are having a look at the different layers of OSGI and where and how they are used. Other questions discussed are: What means dynamicity in an OSGI environment? Where is OSGI used? What’s the future of OSGI? How does OSGI interact with existing middle...
Episode 79: Small Memory Software with Weir and Noble
December 03, 2007 09:19 - 1 hour - 55 MBIn this Episode we're discussing patterns for small memory software with the authors of the like-named book Charles Weir and James Noble. We look at various aspects of the small memory problem: How can you manage memory use across a whole system? What can you do when you have run out of primary storage? How can you fit a quart of data into a pint pot of memory? How can you reduce the memory needed for your data? How do you allocate memory to store your data structures? Answers to all those qu...
Episode 78: Fault Tolerance with Bob Hanmer Pt. 2
November 23, 2007 10:58 - 45 minutes - 41.9 MBThis is the second part of the discussion on fault tolerance with Bob Hanmer (if you didn't listen to Episode 77, which contains part one, please go back and listen now; this episode builds on that previous one!) We start by discussing a set of error detection patterns. Among are the well-known approaches such as checksums and voting. We then look at error recovery patterns, including restart, rollback or roll forward. The next section looks at error mitigation patterns, which include sheddi...
Episode 77: Fault Tolerance with Bob Hanmer Pt. 1
November 13, 2007 19:08 - 45 minutes - 41.9 MBIn this Episode we discuss fault tolerance based on the new book by Bob Hanmer. This is the actually the first part of the discussion, the remainder will be published in the next episode of SE Radio. We start by discussing some of the context for fault tolerant systems and the imperfect world assumption. We then discuss a number of terms we will need when discussing the fault tolerance patterns. We then discuss the fault tolerance mindset and connect fault tolerance to a number of related s...
Episode 76: Special Episode on the Patterns Journal
November 09, 2007 19:17 - 15 minutes - 14.2 MBIn this special Episode we briefly discuss the upcoming Patterns Journal with the two editors, Ralph Johnson and James Noble.
Episode 75: The New Website
November 04, 2007 15:18 - 7 minutes - 6.92 MBIn this special Episode we briefly discuss our new website. We will migrate to our new website during the coming week. If you experience any difficulties, contact the team or temporarily go to the old site at seradio.libsyn.com.
Episode 74: Enterprise Architecture II
November 03, 2007 11:35 - 45 minutes - 41.4 MBEnterprise Architecture is already common practice in most Fortune 100 companies. As the topic is comparably young, knowledge about it is not so widespread in the Software Architects Community, who deals mostly with project architectures. In this episode Alex speaks with Wolfgang Keller who has practical experience as an enterprise architect and has written a book on the topic. He is a Partner with BusinessGlue Consulting. They are specializing in the relationship between EAM and SOA. This ep...
Episode 73: Real Time Systems with Bruce Powel Douglass
October 24, 2007 18:23 - 1 hour - 55.2 MBThis episode is a conversation with Bruce Powel Douglass on real time systems. We started by discussing what real time software is, and explored the difference between hard and soft real time. We then looked at different scheduling strategies, and the meaning of terms like urgency and importance in the context of scheduling. Next was a discussion of typical architectural styles for real time systems and how architectures are described in this context. This led us to a discussion about the imp...
Episode 72: Erik Meijer on LINQ
October 17, 2007 18:13 - 52 minutes - 48.4 MBThis episode is a discussion with Erik Meijer on LINQ. This is a relatively technical discussion about the following topics: what is LINQ, what are the common abstractions between the different data structures one can access with LINQ, what is the relationship to established languages for querying, how does the integration into the type system of the host language work, how to specify the mapping between the language level classes and the data, and how optimizations are implemented (lazy load...
Episode 71: Survey Results
October 13, 2007 18:09 - 32 minutes - 29.7 MBIn this Episode I talk about the results of the listener survey and reply to some of the suggestions and criticism expressed in survey replies.
Episode 70: Gerard Meszaros on XUnit Test Patterns
October 04, 2007 17:59 - 52 minutes - 48.3 MBIn this episode we talk with Gerard Meszaros about problems and challenges doing unit testing in real-world projects. Starting from a short discussion about the importance of automated unit testing we spend most of this episode to talk about every day problems doing unit testing and how those problems can be solved. Based on this book on xunit testing patterns, Gerard talks about his experiences with unit test smells as an analogy to code smells. He describes an impressive set of unit testing...
Episode 69: Nico Josuttis on SOA (SOA Pt. 3)
September 24, 2007 22:00 - 56 minutes - 52 MBThis Episode is part five in our (probably ongoing) series on service oriented architecture. In this episode we talk to Nico Josuttis, who has recently published a book on this topic. As its title "SOA in Practice" suggests, it is a very pragmatic book based on Nico's experience as architect and project lead in a number of enterprise-level projects - not all of them had been called SOA, since they at the time the term was not yet coined. The episode discusses some technical aspects of SOA (su...
Episode 68: Dan Grossman on Garbage Collection and Transactional Memory
September 14, 2007 14:22 - 54 minutes - 49.7 MBThis episode features a discussion with Dan Grossman about an essay paper he wrote for this year's OOPSLA conference. The paper is about an analogy between garbage collection and transactional memory. In addition to seeing the beauty of the analogy, the discussion also serves as a good introduction to transactional memory (which was mentioned in the Goetz/Holmes episode) and - to some extent - to garbage collection.
Episode 67: Roundtable on MDSD and PLE
September 04, 2007 14:30 - 48 minutes - 44.6 MBThis is a roundtable discussion on model-driven software develoment and product line engineering. It was recorded at the Model-Driven Development and Product Lines: Synergies and Experience conference in October 2006 in Leipzig. The panelists are: Axel Uhl, SAP Danilo Beuche, Pure Systems Juha Pekka Tolvanen, MetaCase Tom Stahl, b+m Ruediger Schilling, Delta Software Technology
Episode 66: Gary McGraw on Security
August 24, 2007 22:00 - 41 minutes - 37.6 MBThis episode features an interview with the software security expert Gary McGraw. Gary explains why this topic is so important and gives several security deficiencies examples that he found in the past. The second half of the interview is about his latest book 'Exploiting Online Games' where he explains how online games are hacked and why this is relevant to everybody, not only gamers in their 'First Life'.
Episode 65: Introduction to Embedded Systems
August 14, 2007 22:00 - 44 minutes - 40.3 MBThis episode is an introduction to embedded system. It is an introduction in the sense that we cover many topics very briefly: upcoming episodes will provides details for many of these topics. We start by discussing what an embedded system is an what the important characteristics are. Among them is limited resources, concurrency, real time and hardware integration. We also discuss the range of embedded systems from small mirocontrollers to mobile phones to distributed real time embedded syste...
Episode 64: Luke Hohmann on Architecture and Business
August 04, 2007 22:00 - 52 minutes - 48.3 MBIn this episode we talk about the relationship between software architecture and the business. Based on his book, Beyond Software Architecture we discuss how things such as branding, licensing, updating or different deployment scenarios influence the technical architecture of a system. We also discuss issues such as portability that add a huge amount of complexity, although from a business perspective it often does not make much sense. In the second part of the interview we discuss how the te...
Episode 63: A Pattern Language for Distributed Systems with Henney and Buschmann
July 25, 2007 22:00 - 1 hour - 61 MBIn this Episode we talked about the new POSA 4 book which has recently been published. We talk to two of the authors, Kevlin Henney and Frank Buschmann (the third author, Doug Schmidt was not available - and he had also been on the podcast a couple of times :-)). The book contains a pattern language for distributed systems. It contains 114 patterns that had been published before by many different other authors. The patterns have been rewritten to form a consistent language. We basically talke...
Episode 62: Martin Odersky on Scala
July 15, 2007 22:00 - 53 minutes - 49.4 MBIn this Episode we talk about the Scala language with its creator Martin Odersky. Scala is a language that fuses object oriented and functional programming. Martin started out by providing a two-minute overview over the language, and then talked a little bit about its history. We then discussed the basics of functional programming. The main part of the episode features a discussion of some of the important features of the Scala language: Case Classes and Pattern Matching Multiple Inheritanc...
Episode 61: Internals of GCC
July 05, 2007 22:00 - 53 minutes - 48.7 MBThis show takes a behind-the-scenes look at compilers and their inner workings, using the Gnu compiler collection (GCC) as an example. Arno interview Morgan Deters, covering all steps from the parsing of different programming languages to machine independenet optimizations and generating processor specific binary code.
Episode 60: Roman Pichler on Scrum
June 25, 2007 22:00 - 1 hour - 55.5 MBThis episode features Scrum, a very popular Agile software development framework. We interview Roman Pichler, a Certified ScrumMaster Trainer and independent consultant. Roman explains the principles behind Scrum, its roles and its key practices. He also answers FAQs. This episode continues our track on software development processes discussing an additional Agile method. Roman is currently writing a book on Scrum in German that provides more in-depth information of the topics discussed in th...
Episode 59: Static Code Analysis
June 16, 2007 11:52 - 45 minutes - 41.9 MBThis episode is a discussion with Jonathan Aldrich (Assistant Professor at CMU) about static analysis. The discussion covered theory as well as practice and tools. We started with an explanation of what static analysis actually is, which kinds of errors it can find and how it is different from testing and reviews. The core challenge of such an analysis tool is to understand the semantics of the program and reduce its possible state space to make it analysable - in effect reconstructing the pr...
Episode 58: Product Line Engineering Pt. 2
June 06, 2007 12:02 - 48 minutes - 44 MBVariability is one of the key concerns in software product line engineering. The episode introduces the concepts of structural and non-structural (or configurative) variability. It also discusses how to find and model variability, and especially how to implement variability in the solution artifacts. Michael and Markus discuss a series of variability mechanisms that can be used with today's programming languages and technologies.