Software Engineering Radio - the podcast for professional software developers

Changeable 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 i...

This 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?...

This 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...

This 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.

In 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 a...

This 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.

This 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 e...

This 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 mig...

Designers, 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 kn...

This 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. T...

This 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...

This episode mainly outlines the upcoming programming and interviews.

In 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.

This 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 in...

In 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...

In 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 nic...

In 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.

The 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.

In 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.

SOA (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.

In 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.

In 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.

In 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 eXt...

This 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 t...

This 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 t...