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 57: Compile-Time Metaprogramming
May 27, 2007 17:07 - 44 minutes - 41.1 MBThis episode is about compile-time metaprogramming, and specifically, about implementing DSLs via compile-time metaprogramming. Our guest, Laurence Tratt, illustrates the idea with his (research) programming language called Converge. We started by talking about the importance of a custom syntax for DSL and took a brief look at the definition of DSLs by a chap called Paul Hudak. We then briefly covered the disctinction between internal and external DSLs. More to the point of this episode, ...
Episode 56: Sensor Networks
May 17, 2007 17:12 - 44 minutes - 40.8 MBIn this episode we discuss sensor networks with our guest Steffen Schaefer, who is the Technical Thought Leader for Sensors & Actuator Solutions at IBM. The discussion resolves around the TREC device, which can be mounted on containers to track them on their journey over seas, railway tracks and roads. The TREC is a small embedded device developed by Steffen's employer, IBM, that has various sensors and communications channels. In the episode we first talked about container transport in gene...
Episode 55: Refactoring Pt. 2
May 07, 2007 17:37 - 32 minutes - 29.4 MBIn the first episode on Refactoring we talked about the basic ideas behind refactoring and some base principles why refactoring is a key part of software engineering. Now we move on to more complicated refactorings and discuss three major situations, their problems and possible solutions: advanced refactorings in large projects that can hardly be finished in a few minutes or hours and refactoring in larger teams. Also covered are the refactoring of published APIs and how merciless refactoring...
Episode 54: Interview Frank Buschmann
April 27, 2007 07:06 - 42 minutes - 38.8 MBThis episode is an interview with Frank Buschmann, one of the pioneers of the pattern movement in Europe. Michael and Frank discuss how it all began: the first conferences on patterns and the first publications by the Gang-of-Four and the POSA 1 team. Frank then elaborates on the new volumes in the Pattern-Oriented Software Architecture book series - POSA 4 and POSA 5 - and gives some examples from the books. The episode concludes with a general discussion on software design and architecture,...
Episode 53: Product Line Engineering Pt. 1
April 17, 2007 07:08 - 44 minutes - 41.1 MBMichael Kircher and Markus Voelter introduce the topic of software product line engineering. They motivate when and why product lines are important to consider and what makes them so special. Further, they introduce some key terminology, such as platform, core asset, feature model, commonality, and variability.
Episode 52: DSL Development in Ruby
April 07, 2007 07:52 - 50 minutes - 46.4 MBIn this episode, we're talking to Obie Fernandez about agile DSL development in Ruby. We started our discussion by defining what a DSL is, the difference between internal and external DSLs as well as the importance of the flexibly syntax of the host language in order to make DSLs worthwhile. We then looked at a couple of real world examples for DSLs, specifically, at Business Natural Languages. We then progressed to the main part of the discussions, which centered around the features of Ruby ...
Episode 51: Design By Contract
March 28, 2007 07:57 - 37 minutes - 34.1 MBIn this episode, Arno and Michael take a look at Design by Contract, a programming technique formalized by Bertrand Meyer. The idea is that an interface is more than method signatures - it is also about specifying the expected behavior that implementations must provide. While some languages include direct support for this style of programming, it is a useful mindset when desiging interfaces even without such language features.
Episode 50: Announcements and Requests
March 22, 2007 07:10 - 8 minutes - 7.71 MBThis is another episode where we mainly announce topics related to the podcast itself.
Episode 49: Dynamic Languages for Static Minds
March 18, 2007 07:15 - 33 minutes - 30.3 MBIn this Episode we talk about dynamic languages for statically-typed minds, or in other words: which are the interesting features people should learn when they go from a langauge such as Java or C# to a language like Python or Ruby. We used Ruby as the concrete example language. We started the discussion about important features with the concept of dynamically changing an object's type and the idea of message passing. We then looked at the concepts of blocks and closures. Next in line is a d...
Episode 48: Interview Dragos Manolescua
March 08, 2007 07:50 - 45 minutes - 41.5 MBIn this Episode we discuss software architecture evaluation with Dragos Manolescu, an architect at Microsoft's patterns & practices group. We start off the discussion by trying to define what software architecture evaluation is and when and you want to evaluate an architecture in the system's lifecycle. We then make sure evaluators set the expectations for the evaluation process right - it is important to understand that architecture evaluation is typically not primarily a review of the tec...
Episode 47: Interview Grady Booch
February 26, 2007 09:16 - 40 minutes - 37.1 MBIn this Episode we are happy to talk to Grady Booch. We started off by discussing his Architecture Handbook, how it came into being, the progress, and how it will look like once it's finished. In this context we also looked at the issue of how to distinguish architecture from design. We then asked him about how "professional" software architecture is these days, as well as about the ubiquity of software product lines in industry. The next couple of minutes looked at the question of whether s...
Episode 46: Refactoring Pt. 1
February 16, 2007 09:25 - 37 minutes - 34 MBChangeable software has been a goal of several technique in software engineering. Probably the most important is Refactoring, changing the code without changing the behaviour (or at least without breaking the tests). In this episode Eberhard talks with Martin Lippert about this technique. The episode covers a history of refactoring, a definition of code smells and how to actually do refactorings in your everyday work. Also some advanced topics - like the ROI of Refactoring or Refactoring in d...
Episode 45: Round Table on Ultra Large Scale Systems
February 06, 2007 10:00 - 52 minutes - 48 MBThis Episode is a round table discussion about Ultra-Large Scale Systems. In 2006, a number of authors (among them our guests Linda Northrop, Doug Schmidt, Kevin Sullivan, and Gregor Kiczales) have produced a report that addressed the following question: Given the issues with today's software engineering, how can we build the systems of the future that are likely to have billions of lines of code? In this episode, our guests discuss many of the issues that arise from this kind of system a...
Episode 44: Interview Brian Goetz and David Holmes
January 27, 2007 10:06 - 49 minutes - 45.3 MBThis is another episode on concurrency. We talk to two experts in the field, Brian Goetz and David Holmes about aspects of concurrency we hadn't really covered before. We start out by discussing liveness and safety and then continue to talk about synchronizers (latches, barriers, semaphores) as well as the importance of agreeing on protocols when developing concurrent applications. We then talked about thread confinement as a way of building thread-safe programs, as well as using functional...
Episode 43: eXtreme Programming Pt.2
January 17, 2007 10:08 - 1 hour - 68.2 MBThis is the second part of our two part discussion of the eXtreme Programming development methodology. While the first part introduced the values, principles and basic practices, this time Arno and Alex speak about the practices that set the context for an XP project and how to get started, and they discuss some FAQs they often get when introducing XP.
Episode 42: Interview Gregor Hohpe
January 07, 2007 10:13 - 1 hour - 59.4 MBIn this episode, Gregor Hohpe gives us a great introduction to enterprise messaging based on his EAI Patterns book. Before we started discusssing the patterns in his book, we characterized messaging and talked about the various interaction styles. We also contrasted the messaging architectural style with an RPC based approach. We then took a look at the relationship to SOA, the role of contracts and the orchestration-vs-choreography discussion. We briefly discussed the nature of pattern langu...
Episode 41: Architecture Patterns (Architecture Pt. 4)
December 27, 2006 10:14 - 47 minutes - 43.4 MBThis is the fourth and final episode on the fundamentals of Software Architecture. We talk mainly about architectural styles and patterns, as introduced in the POSA 1 Book. We also discuss a little bit the process of actually using those patterns for architecting systems.
Episode 40: Interview Werner Vogels
December 16, 2006 11:58 - 40 minutes - 37.2 MBThis episode is an interview with Werner Vogels, the CTO of amazon.com. We first talked about what scalability is, and which aspects there are to scalability. We then took a brief look at the technologies used at amazon, specifically, the middleware systems and the issue of vendor lock-in. Web services, and the role of SOA was the next topic. Then we covered what a service actually is add Werner explained the term "pizza teams". Testing and Deployment was the next topic followed by a look at ...
Episode 39: Interview Steve Vinoski
December 06, 2006 12:01 - 38 minutes - 35.4 MBThis episode is an interview with Steve Vinoski. Steve works as the Chief Engineer for IONA. He's what you'd call a middleware guru, he was for example deeply involved with CORBA. So, this interview centers mainly around middleware. We begin by talking about his own history wrt. middleare and ORBs and how ORBs evolved over time. We then talked about whether coarse-grained, stateless components might be a better abstraction for distributed systems than "objects". We then covered the future of ...
Episode 38: Interview James Noble
November 26, 2006 12:03 - 20 minutes - 19.1 MBDesigners, programmers, engineers, we must all return to programming! Very few programmers tend to see their (sometimes rather general) difficulties as the core of the subject and as a result there is a widely held consensus as to what programming is really about. If these notes prove to be a source of recognition or to give you the appreciation that we have simply written down what you already know about the programmer's trade, some of our goals will have been reached.
Episode 37: eXtreme Programming Pt.1
November 18, 2006 12:07 - 1 hour - 57.6 MBThis is the first of two episodes where Arno and Alex discuss eXtreme Programming in se-radio's development process track. eXtreme Programming (XP) revolutionized the way of thinking about software development methodologies and helped to make the agile movement popular. In this episode they discuss the very basics of XP, its value system, principles and the basic practices used in an XP project. The second episode will continue the introduction adding the missing practices and how to introduc...
Episode 36: Interview Guy Steele
November 10, 2006 12:11 - 28 minutes - 26.1 MBThis episode is an interview with Guy L. Steele Jr.. Guy is a Sun Fellow and heads the Programming Language Research Group within Sun, and a generally well known "programming language guy" (see here for details). We briefly talk about Lisp and the resurgence of dynamic languages before we delve into the main topic, the Fortress programming language he is working on. Fortress is a language intended to replace Fortran as a scientific computing language. We talk about how mathematical notations,...
Episode 35: Roadmap
November 08, 2006 12:13 - 10 minutes - 9.71 MBThis episode mainly outlines the upcoming programming and interviews.
Episode 34: Enterprise Architecture
November 02, 2006 12:17 - 1 hour - 56 MBIn this episode Markus and our Guest Andy Longshaw talk about enterprise architecture. More specifically, we talk about some of the patterns in Andy Longshaw's and Paul Dyson's book Architecting Enterprise Solutions: Patterns for High-Capability Internet-based Systems. These includes things like replication, load balancing, monitoring and application management.
Episode 33: Service Oriented Architecture, Pt.2b
October 23, 2006 13:19 - 45 minutes - 41.8 MBThis is the second snippet of the SOA 2 double-episode. Eberhard and Markus continue the discussion with the issue of service reuse and a couple of development process issues. We also look at the duality between infrastructure development and application development in the context of an SOA. We then discuss the great spaghetti misunderstanding :-). We conclude this episode with a look at how to integrate BPM into the conceptual SOA framework we've built up to now, and we'll also briefly skim ...
Episode 32: Service Oriented Architecture, Pt.2a
October 13, 2006 13:20 - 51 minutes - 47.5 MBIn this, as well as in the next episode Eberhard and Markus continue their discussion about SOA (the episode got too long, so we had to split it into two ... SOA 2a and SOA 2b). In this episode, we talk about the various perspectives on SOA (CBD, EAI, BPM), about fundamental requirements towards an SOA, and we discuss the role of models in defining sustainable architectures. We also discuss how a programming model based on the described approach typically looks like. We then discuss a number ...
Episode 31: Agile Documentation
October 03, 2006 13:27 - 44 minutes - 40.3 MBIn this episode, our guest Andreas Rueping and Markus talk about documenting software. While this is a topic that many people don't like or consider fun, it is nonetheless very important. Based on his book, Agile Documentation, we talk about various aspects documenting software such as what to document, when to document, which media to use as well as specifically a number of layouting tips for nice documents.
Episode 30: Architecture Pt.3
September 22, 2006 22:00 - 30 minutes - 27.6 MBIn this third Episode on software architecture, Michael and Markus talk about the basic tools that an architect uses when architecting systems. These tools include things like separation, abstraction, compression and sharing. We also relate these tools to the quality attributes we introduced in previous archtecture episodes.
Episode 29: Concurrency Pt.3
September 12, 2006 22:00 - 36 minutes - 33.4 MBThe third part of our concurrency series by Michael and Alexander discusses how to build highly scalable servers. The discussion focusses especially on event-driven servers. As possible solution patterns a reactor-based design is suggested along-side several patterns for multi-threading issues: Reader/Writers Locks, Thread Pools, and Leader/Followers.
Episode 28: Type Systems
September 02, 2006 22:00 - 46 minutes - 42.9 MBIn recent episodes we have discusses statically and dynamically typed languages and domain specific languages - topics that are much talked about in the community at the moment. In this episode we look at the foundation of programming languages : types. We explain what a type actually is, how type systems work and what polymorphism works.
Episode 27: Service Oriented Architecture Pt.1
August 23, 2006 22:00 - 48 minutes - 44.7 MBSOA (Service Oriented Architecture) appears to be just another hype - after all we have been building distributed systems for quite a while now. But the real value of SOA is non-technical. In this episode Eberhard and Markus discuss the advantages and disadvantages, what SOA actually is and how it compares to other approaches that have been tried out before.
Episode 26: Interview Jutta Eckstein
August 13, 2006 22:00 - 45 minutes - 41.8 MBIn this Episode, Arno, Bernd and Markus interview Jutta Eckstein. Jutta is a pioneer and expert on using Agile software development, specifically in larger teams. In the interview we talk about the agile manifesto, the role of personal relationships and trust in software projects, differences between agility in the small and in the large, as well as offshoring.
Episode 25: Architecture Pt. 2
August 03, 2006 22:00 - 32 minutes - 30.1 MBIn this Episode, Michael and Markus continue the discussion about the fundamentals of software architecture (we're doing it without Alex, because it is really hard to find a suitable time for all of us on the phone :-)). We talk about the various quality attributes (such as performance, scalability, maintainability and many more) and how they relate to each other.
Episode 24: Development Processes Pt.1
July 24, 2006 22:00 - 47 minutes - 43.2 MBIn this episode Arno and Alex talk about the basics of software development processes. They discuss why and when software development processes are needed and also why some developers don't like them. They discuss the theories behind different processes and talk about defined vs empiric processes in general. This episode is the first in a row that will later on describe specific processes like eXtreme programming or the unified process.
Episode 23: Architecture Pt. 1
July 14, 2006 22:00 - 42 minutes - 38.9 MBThis is the first of a series of Episodes on Software Architecture. Alex, Michael and Markus talk about rather fundamental topics in this episode, we'll go into much more detail in subsequent episodes in that series. Topics in this episode include: What is architecture, how is it different from design what different kinds of architecture are there in addition to software architecture the role of the architect, do we have one or more? architecture in agile software development tasks of th...
Episode 22: Feedback
July 09, 2006 22:00 - 23 minutes - 21.2 MBThis is an episode with some more of your feedback. Specifically, the episode also contains a 5 minute section from Geert Bevin where he explains how Continuations are used an implemented in the Rife Framework. This is in response to a discussion about continuations and Rife in Episode 15, Future of Enterprise Java. We also have some feedback from Bill Pugh about flaws in our description about the problems of double-checked locking in Java.
Episode 21: Error Handling Pt. 2
July 04, 2006 22:00 - 35 minutes - 32.9 MBIn this Episode, Arno and Michael take a closer look at Exceptions and Error conditions, how to categorize them and how to deal with them. We look at the different levels of guarantee that a piece of code can provide with regard to exceptional condition and finish with a discussion of a number of best practices and their respective trade-offs.
Episode 20: Interview Michael Stal
June 24, 2006 22:00 - 43 minutes - 40.3 MBIn this Episode, we talk to Michael Stal, a Senior Principal Engineer at Siemens Corporate Technology, POSA 1 and 2 Co-Author and Editor of the german JavaSpetrum magazine. Since Michael's core focus is middlware, much of our discussion centered around that topic. Webservices and SOA, of course, have also been covered. Other topics include Java vs. .NET as well as Patterns.
Episode 19: Concurrency Pt. 2
June 14, 2006 22:00 - 27 minutes - 25.4 MBIn this second part of our concurrency series Michael and Alexander talk about basic patterns for concurrent programming, such as Active and Monitor Object, Scoped Locking and Futures. Further, they discuss some architectural considerations regarding the number of threads and resource usage in general. For more information, see the references for part one as well as the following links
Episode 18: Resource Management
June 04, 2006 22:00 - 43 minutes - 39.8 MBIn this episode Michael and our guest Prashant Jain talk about patterns for resource management. Efficient management of resources is critical in the execution of any kind of software. Ranging from embedded software in a mobile device to software in a large enterprise server, it is important that the resources, such as memory, threads, file handles, or network connections, are managed efficiently to allow the systems to function properly and effectively. Michael and Prashant discuss various p...
Episode 17: Feedback and Roadmap
May 29, 2006 22:00 - 14 minutes - 13.7 MBThis is a short episode that outlines the upcoming episodes and interviews, as well as reports on some listener feedback.
Episode 16: MDSD Pt. 3, Hands-On
May 25, 2006 22:00 - 1 hour - 55.2 MBThis episode provides a hands-on guided tour through a simple model-driven software project. It is based on an actual code sample (see link below) and takes a look at the typical steps of real-life code generation: prototypical implementation, defining the metamodel, reading a model into a metamodel instance, writing templates and validating the model. The example for the episode uses openArchitectureWare as a generator environment, but the overall approach is tool independent. This episode i...
Episode 15: The Future of Enterprise Java
May 15, 2006 22:00 - 37 minutes - 34.7 MBA very important area for Java are Enterprise Systems. With the advent of new technologies like Ruby on Rails, Java EE 5 or EJB 3 the landscape for Enterprise Systems appears to be changing a lot at the moment. In this episode Markus talks with Eberhard about what Enterprise Java actually is, why and where it is used. Based on that they discuss what the future might look like and how to make Enterprise Java shine in the future.
Episode 14: Interview Ted Neward
May 05, 2006 22:00 - 1 hour - 59.2 MBIn this Episode we talk to Ted Neward. Since Ted is active in the .NET and Java universes, we started out by discussing some of the differences between the two platforms. The main discussion, however, focussed on new features in the C# 3.0 language. These include LINQ (language-integrated query). A very interesting discussion about extension methods, lamda expression, typing (dynamic, duck, compiler) and other language "tricks" follows. We also visited the topic of language development on the...
Episode 13: Ruby in Practice
April 26, 2006 22:00 - 31 minutes - 29.1 MBRuby has been getting more and more attention by the developer community over the last couple of years. Nevertheless Ruby as language and as a plattform is not too widespread. Most developers don't know people who have actually done commercial Ruby projects. Therefore it is sometimes hard to judge if Ruby is just a hype topic or if Ruby can be used for serious projects today. In this episode Alexander speaks with Thomas Quas about a commercial Ruby project Thomas finished a while ago. Thomas ...
Episode 12: Concurrency Pt. 1
April 18, 2006 22:00 - 25 minutes - 23.1 MBThis is the first part of a series of Concurrency episodes. In this part Alex and Michael motivate and introduce the topic. We explain fundamental terms, such as thread, process, or mutex and dicuss typical challenges, such as deadlocks and race conditions.
Episode 11: Interview Gregor Kiczales
April 08, 2006 22:00 - 34 minutes - 31.3 MBIn this Episode we have the pleasure of talking with Gregor Kiczales. Gregor is one of the fathers of aspect-oriented programming (AOP). Today he is a professor of computer science at the University of British Columbia. Back in his days at Xerox Parc, he and a number of other people worked on the early forms of AOP as well as on some of its forerunners, such as meta object protocols. In this interview, we talk about a number of interesting topics, such as the history of AOP, the relationship ...
Episode 10: Remoting Pt. 2
March 29, 2006 22:00 - 34 minutes - 31.8 MBThis is the second part of the remoting infrastructures discussion started in Episode 9. We take a look at how remoting infrastructures such as CORBA, .NET Remoting or Web Services work internally. This includes the low level details of the transport layer, marshalling, client proxies as well as interceptors and asynchronous communication. At the end, Michael will explain how all this relates to CORBA and Markus will map the concepts to .NET remoting. We don't have additional links in these s...
Episode 9: Remoting Pt.1 and Listener Feedback
March 19, 2006 22:00 - 40 minutes - 36.8 MBThis Episode as well as the next one take a look at remoting infrastructures such as CORBA, .NET Remoting or Webservices. In this first part we will take a look at why remote communication is necessary in the first place, what remoting middleware can do for you as well as which other middleware technologies exist in addition to OO-RPC systems, such as messaging middleware. Finally, we conclude with a brief overview of what the broker pattern can do for us in the context of remoting middleware.
Episode 8: Interview Eric Evans
March 08, 2006 22:00 - 38 minutes - 35.5 MBEric Evans is the author of the well known Domain-Driven Design book. In his day job he works as a consultant and coach for his own company, Domain Language. In this interview, Eric talks about the essential building blocks of domain-driven design as well as about a set of best practices on how to address complex projects. In a third part, he elaborates on the relationship of domain-driven design and MDSD/MDA.