Software Engineering Radio

E86: OTI Dave

Mon, 11 Feb 2008 13:06:00 GMT

E85: Webservices

Fri, 1 Feb 2008 13:05:00 GMT

E84: Lisp

Tue, 22 Jan 2008 10:05:00 GMT

E83

Sat, 12 Jan 2008 21:54:00 GMT

E82

Wed, 2 Jan 2008 21:54:00 GMT

E81

Sun, 23 Dec 2007 17:21:00 GMT

E80

Thu, 13 Dec 2007 05:11:00 GMT

E79

Mon, 3 Dec 2007 10:10:00 GMT

Episode 78: Fault Tolerance with Bob Hanmer II

Fri, 23 Nov 2007 11:46:00 GMT

Episode 77: Fault Tolerance with Bob Hanmer

Tue, 13 Nov 2007 20:02:00 GMT

Please go to se-radio.net for the new website and the new feed.

Episode 76: The Patterns Journal

Sat, 10 Nov 2007 13:00:00 GMT

Guest: Ralph Johnson, James Noble
Host: Markus

In this special Episode we briefly discuss the upcoming Patterns Journal with the two editors, Ralph Johnson and James Noble.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 75: The New Website

Sun, 4 Nov 2007 16:16:00 GMT

Host: Bernd and Markus

In 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.
Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 74: Enterprise Architecture II

Sat, 3 Nov 2007 10:30:00 GMT

Guest: Wolfgang Keller
Host: Alex

Enterprise 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 episode gives a rough overview what Enterprise Architecture actually is touches the standards in the field and also gives hints on the practical work of Enterprise Architects.

Wolfgang's Book, IT Unternehmensarchitektur
The TOGAF Framework
COBIT
Itil

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 73: Real Time Systems with Bruce Powel Douglass

Wed, 24 Oct 2007 20:30:00 GMT

Guest: Bruce Powel Douglass, Chief Evangelist at Telelogic
Host: Markus

This 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 importance of modeling, formalisms and languages as well as the role of automatic code generation from those models. We then looked at how to model QoS aspects and the role of SysML for modeling real time systems. We then had a brief look at which programming languages are used these days for real time systems and the role of static analysis to determine various properties of those programs in advance. The last part of the discussion focused on some best practices for building real time systems, the challenges in distributed real time systems and how real time systems can be tested effectively.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 72: Erik Meijer on LINQ

Wed, 17 Oct 2007 11:23:00 GMT

Guest: Erik Meijer
Host: Arno

This 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 loading, prefetching, etc.).

Erik's web page
The LINQ project
LINQ explained at Wikipedia
Video Interview with Anders Hejlsberg on LINQ

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 71: Survey Results

Sat, 13 Oct 2007 10:58:00 GMT

Host: Markus

In this Episode I talk about the results of the listener survey and reply to some of the suggestions and criticism expressed in survey replies.
Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 70: Gerard Meszaros on XUnit Test Patterns

Thu, 4 Oct 2007 04:42:00 GMT

Guest: Gerard Meszaros
Host: Martin

In 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 patterns to overcome those difficult testing situations and illustrates them with nice examples everybody doing unit testing will feel familiar with.

Book: xUnit Test Patterns – Refactoring Test Code
Website on xUnit Test Patterns
xUnit on Wikipedia

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 69: Nico Josuttis on SOA (SOA Pt. 5)

Mon, 24 Sep 2007 04:49:00 GMT

Guest: Nico Josuttis
Host: Markus

This 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 (such as loose coupling, messaging and ESBs), but mainly focusses on non-technical aspects of implementing an SOA.

Nico's Homepage
SOA in Practice book
Nico's SOA Glossary
Book: Service Orientation: Winning Strategies and Best Practices by Paul Allan
Book: Service Orient or Be Doomed - How Service Orientation Will Change Your Business by Jason Bloomberg, Ronald Schmelzer
The Business Process Modeling Notation
Book: Service-Oriented Architecture - Concepts, Technology, and Design by Thomas Erl

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 68: Dan Grossman on Garbage Collection and Transactional Memory

Fri, 14 Sep 2007 05:09:00 GMT

Guests: Dan Grossman
Host: Markus

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

The paper on which this episode is based. You should read it to see the full beauty of the analogy
Wikipedia on Transactional Memory
Wikipedia on Garbage Collection
Paper: A unified theory of garbage collection
Paper: Transactional memory: architectural support for lock-free data structures

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 67: Roundtable on MDSD and PLE

Tue, 4 Sep 2007 04:18:00 GMT

Guests: Axel Uhl, Danilo Beuche, Juha Pekka Tolvanen, Tom Stahl, Ruediger Schilling
Host: Markus

This 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

The lively discussion resolved around topics such as MOF, XMI, the way the OMG defines standards, architecture-driven modernizatin (ADM), and the relationship of the product lines communities and the model-driven and DSL communities.

OMG's Meta Object Facility (MOF),
an overview over the CDIF standard
XML Meta Data Interchange (XMI)
Query/Views/Transformations
OMG's Architecture-Driven Modernization workgroup
The Common Warenhouse Meta Model (CWM)

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 66: Gary McGraw on Security

Sat, 25 Aug 2007 08:48:00 GMT

Guest: Gary McGraw
Host: Michael

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

Software Security - one of Gary McGraw's web sites
Exploiting Online Games - his latest book

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 65: Introduction to Embedded Systems

Wed, 15 Aug 2007 18:20:00 GMT

Hosts: Michael and Markus

This 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 systems. We also cover the different business case for embedded systems (per unit cost) and some non-trivial developmental aspects (cross compilation debugging, heisenbugs).
We close the episode by discussing some important architectural styles (time triggered, event-based, microkernels, state machines) as well as tools of the trade: languages, operating systems and middleware.
Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 64: Luke Hohmann on Architecture and Business

Sun, 5 Aug 2007 09:40:00 GMT

Guest: Luke Hohmann
Host: Markus

In 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 technical team and the business team can improve the way they work together. We look at some of the games (such as Buy a Feature or Give them a Hot Tub) from his new book Innovation Games, which discusses how to use collaborative play to be more creative and innovative in product creation.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 63: A Pattern Language for Distributed Systems with Henney and Buschmann

Thu, 26 Jul 2007 04:20:00 GMT

Guest: Kevlin Henney and Frank Buschmann
Host: Markus
recorded at: OOP 2007

In 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 talked through the different sections of the book, which gives a really good overview over the challenges and the solutions of building distributed systems. These sections include From Mud to Structure, Distribution Infrastructure, Event Demultiplexing and Dispatching, Interface Partitioning, Component Patitioning, Application Contrl, Concurrency, Synchronization, Object Interaction, Adaptazion and Extension, Modal Behaviour, Resource Management and finally, Database Access.

The book references several other previous works (as listed below). Interestingly, many of these referenced works and authors have also been discussed previously on the podcast. Here are the back references:

Domain Driven Design, Eric Evans
Messaging Patterns, Gregor Hohpe
POSA 2 Patterns, Doug Schmidt
Concurrency: Part 1, Part 2, Part 3 and the interview with Goetz and Holmes
Remoting Patterns Part 1 and Part 2
POSA3, Resource Management

Here are some of the books and publications mentioned in the discussion:

POSA 1, 2, 3, 4, 5
Server Component Patterns book, Remoting Patterns book
Eric Evans's DDD book
Martin Fowler's Analysis Patterns, Patterns of Enterprise Architecture
Gregor Hohpe's Messaging book
Security Patterns book
Jens Coldewey's Database Stuff

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 62: Martin Odersky on Scala

Mon, 16 Jul 2007 18:42:00 GMT

Guest: Martin Odersky
Host: Markus

In 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 Inheritance and Compound Types, Traits, Mixins
Closures
Functions as types, "Function pointers", Anonymous functions
Higher Order Functions
Currying
(Sequence) Comprehensions
Generics
Type Bounds (Upper, Lower)
Static/Dynamic Typing, Type Inference
Operators
Implicits

We then talked about Scala's actors library, a highly scalable concurrency package. The last part of the episode covered some more general topics, such as where and how Scala is used today, IDE support and the user and developer community. We concluded the episode by looking at current development and next steps in Scala language evolution.

Scala language web site
Martin Odersky's web site
Scalazine, a magazine for the Scala programming community
Martin's Blog
Scala by Example (PDF)
Scala Actors Tutorial

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 61: Internals of GCC

Fri, 6 Jul 2007 07:15:00 GMT

Guest: Morgan Deters
Host: Arno

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

Aho, Sethi, Ullmann: Compilers: Principles, Techniques and Tools (the Dragon book)
The Gnu Compiler Collection (GCC)

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 60: Roman Pichler on Scrum

Tue, 26 Jun 2007 05:46:00 GMT

Guest: Roman Pichler
Host: Alex

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

You can find out more about Scrum here:

The Scrum Alliance Web Site
Ken Schwaber, Mike Beedle: Agile Software Development with SCRUM, Prentice Hall, 2001
Ken Schwaber: Agile Project Management with Scrum, Microsoft Press. 2004
Ken Schwaber: Scrum et al. Google Video
Roman's Web Site

Roman is currently writing a book on Scrum in German that provides more in-depth information of the topics discussed in the podcast. The book will be available in autumn 2007 published by d.punkt (Heidelberg, Germany).

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 59: Static Code Analysis

Sat, 16 Jun 2007 17:25:00 GMT

Guest: Jonathan Aldrich
Host: Markus

This 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 programmer's intent from the code. The user can "help" the tool with this challenge by using suitable annotations; also, languages could do a better job of being analysable. The conceptual discussion was concluded by looking at the principles of static analysis (termination, soundness. precision) and how this approach relates to model analysis.

The second more practical part started out with a discussion of how Microsoft successfully uses static analysis in their Windows development. We then discussed some of the tools available; these include Findbugs, Coverity, Codesonar, Clockwork, Fortify, Polyspace and Codesurfer. To conclude the discussion of tools, we discussed the commonalities and differences with architecture visualization tools as well as metrics and heuristics.

Part three of the discussion briefly looked at how to introduce static analysis tools into an organization's development process and tool chain. We concluded the discussion by looking at situations where static analysis does not work, as well as at the FLUID research project at CMU.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 58: Product Line Engineering Pt. 2

Wed, 6 Jun 2007 12:01:00 GMT

Hosts: Michael and Markus

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

A nice report on Variability in Software Product Lines by Felix Bachmann
Workshop proceedings of the SPLC 2006 workshop on Variability Management - Working with Variability Mechanisms
A presentation that covers most of the aspects discussed in this episode

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 57: Compile-Time Metaprogramming

Sun, 27 May 2007 06:45:00 GMT

Guest: Laurence Tratt
Host: Markus
Recorded at: JAOO 2006

This 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, we discussed the concept of compile-time metaprogramming, and the language features necessary to achieve it: in converge, these concepts are called splice, quasi-quote and insertion. We then looked at how the Converge compiler works, and at the additional features that are required to implement DSLs based on the metaprogramming features mentioned above. Using an example, we then walked through how to implement a simple DSL.

Looking at some of the more technical details, we discussed the difference between the parse tree and the abstract syntax tree and at different kinds of parsers - specifically, the Earley parser used by Converge. In multi-stage languages (i.e. languages that execute programs and meta programs) error reporting is important, but non trivial. We discussed how this is done in Converge. We finally looked at how to integrate Converge's expression language into your DSL and how to package DSL definition for later use.

The last segment look at the process of implementing a DSL in converge and about some of the history and practical experience with Converge. Lessons learned from building Converge wrap up the episode.

Hudak's definition of DSL
The Converge Language
The concepts of compile-time metaprogramming, and another link on this topic
How the converge compiler works
Parse Tree vs. Abstract Syntax Tree
Early Parsers

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 56: Sensor Networks

Thu, 17 May 2007 11:36:00 GMT

Guest: Steffen Schaefer, IBM
Host: Markus
Recorded at: OOPSLA 2006

In 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 general, and then looked at how the TREC device works - specifically, it's hardware, software and power management. We then looked at the necessary backend infrastructure. The main part of the discussion covered the communication between the device and the backend, using technologies such as Zigby, GSM and satellite communications. We also looked at the middleware infrastructures used, such as the MQtt messaging tool.

We closed the episode with a little discussion of the "Internet of Things" and some discussion about embedded software devleopment in general. Note that SE Radio will feature more embedded topics in the future - an introduction to embedded development will be put online soon.

information on a pilot project IBM did on tracking containers stuffed with Heineken beer
interesting workshop papers from OOPSLA06 workshop on Building Software for Sensor Networks. The paper 'Secure Trade Lane: A Sensor Network Solution for more predictable and more secure container shipments' contains details on technology and architecture of the solution we talked about in this episode
rfidjournal.com - great source for any kind of information regarding RFID
epcglobalinc.org - cross-industry RFID standards
flash demo on How the EPC Network works
Sensor Network solutions from IBM
Information on intelligent utility networks
Sun Spots - small wireless Java programmable devices from Sun
MQ Telemetry Transport - Messaging infrastructure for mobile and embedded devices
Zigbee Alliance - information on the Zigbee standard

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 55: Refactoring Pt. 2

Mon, 7 May 2007 13:04:00 GMT

Hosts: Martin and Eberhard

In 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 could be aligned with backward compatibility of published APIs, and refactorings that affect more than just code like for example database schemas.

Martin Fowler's site about refactoring, including a list of refactoring tools for various languages and environments
Refactoring mailing list at Yahoo
Book: Lippert, Roock: Refactoring in Large Software Projects - Performing Complex Restructurings Successfully
Book: Ambler, Sadalage: Refactoring Databases: Evolutionary Database Design
Article: Public versus Published Interfaces, Martin Fowler
Refactoring Thumbnails by Sven Gorts, a nice way to describe and visualize larger refactorings

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 54: Interview Frank Buschmann

Fri, 27 Apr 2007 05:04:00 GMT

Guest: Frank Buschmann
Host: Michael

This 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, and best practices on software development.

Hillside web site
EuroPLoP - the European Conference on Pattern Languages of Programs
Books on Pattern-Oriented Software Architecture

Â
Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 53: Product Line Engineering Pt. 1

Tue, 17 Apr 2007 06:06:00 GMT

Hosts: Michael and Markus

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

A software product line community web site maintained by Charles Krueger, an independent consultant on product line engineering.
The Software Engineering Institute (SEI) is driving some of the community efforts.
The Software Product Lines conference 2007 is the place to meet and discuss with researchers and practitioners.
A nice report on Variability in Software Product Lines by Felix Bachmann.
Krzysztof Czarnecki wrote a very nice Overview of Generative Software Development, where he explains the terms problem and solution space as well as the continuum between 'routine configuration' and 'creative construction'.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 52: DSL Development in Ruby

Sat, 7 Apr 2007 04:01:00 GMT

Guest: Obie Fernandez
Host: Markus
Recorded at: JAOO 2006

In 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 that are important for building DSLs. These include the flexible handling of parentheses, symbols, blocks as well as literal arrays and hashes. We then discussed Ruby's meta programming feautures and how they are important for building DSLs: instantiation, method_missing callback, class macros, top level functions and sandboxing. Features like eval, class_eval, instance_eval and define_method are also important for DSLs in Ruby, as well as using alias_method for simple AOP.

Obie's Web Site
The slides on which this episode is based
Martin Fowler's article on Language Workbenches

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 51: Design By Contract

Wed, 28 Mar 2007 04:01:00 GMT

Hosts: Arno and Michael

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

Book: Bertrand Meyer, Object Oriented Software Construction
The original publication by Betrand Meyer
An introduction to design by contract
ContractJ - DbC with Java 5
Spec# - DbC for C#

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 50: Announcements and Requests

Thu, 22 Mar 2007 07:48:00 GMT

Host: Markus

This is another episode where we mainly announce topics related to the podcast itself. Specifically, this includes:

Please spread the word for Software Engineering Radio by using logos, banners and posters from this page
Please don't forget to vote for us at Podcast Alley from time to time.
Finally, we are asking for help with our website. If you want to build a real nice website for us, including a good content management system, a forum, tagging, etc. please contact the team.

Episode 49: Dynamic Languages for Static Minds

Sun, 18 Mar 2007 08:11:00 GMT

Guest: Niclas Nilsson
Host: Markus
Recorded at: OOPSLA 2006

In 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 discussion about functions that create functions as well as currying. This lead into a quick discussion about continuations. Open classes, aliasing and the relationship to AOP was next on our agenda.

We then looked considered a somewhat more engineering-oriented view and looked at the importance of testing and what are the best steps of getting from static programming to dynamic programming. Finally, we discussed a bit about the current (as of October 2006) state of dynamic languages on mainstream platforms.

Niclas Nilsson's blog
Jim WeirichÃïïs blog
The Seaside web framework
AsepctR, AOP for Ruby
IronPython, Python on .Net
JRuby, Ruby on the JVM
Groovy

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 48: Interview Dragos Manolescu

Thu, 8 Mar 2007 06:33:00 GMT

Guest: Dragos Manolescu
Host: Markus
Recorded at: JAOO 2006

In 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 technology decisions made for the architecture.

We then discuss the kinds of notations that are useful for describing architectures, and which of these are especially helpful for the evaluator. Next we look at the core of the architecture evaluation task, namely, the integration of the various stakeholders and their views. We also discuss real reviews from reviews that are staged "for show" only.

Next in the discussion is a brief look at the tools you can use for architecture evaluation, as well as a closer look at the various methods for achitecture evalualtion proposed by the Software Engineering Institute (SEI). We conclude the discussion by outlining how architecture evaluation fits into an agile development process.

... and finally, we briefly plug the PLOPD5 book, on which Dragos, Markus and James Noble have been working recently :-)

Dragos' Homepage
Dragos' slides on architecture evaluation
Detailed description of ATAM (PDF)
Information about ATAM from softwarearchitectures.com.
Microsoft's patterns & practices group
Inforation about the PLOPD5 book at Dragos' site, at Markus' site and at Amazon

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 47: Interview Grady Booch

Mon, 26 Feb 2007 06:35:00 GMT

Guest: Grady Booch
Host: Markus

In 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 software development is an engineering discipline, craftsmanship or an art form, and we discussed the key qualifications of software developers. Grady then elaborated on the problems of developing in large teams as well as the potential limits of complexity we can tackle with software.

We then got back to a more technical discussion, where we looked at model-driven development, DSLs, etc. and the role of the UML in that context. Next was a discussion about scripting languages, and the current trend towards new languages. We then looked at component marketplaces and other forms of reuse, as well as the importance of OO these days and the relevance of AO. We concluded with a (small) outlook to the future.

Grady's Blog
SEI Software Architecture site
Book: Design Patterns, by the Gang of Four
Some of the books by Henry Petroski
Info on CelsiusTech's Ship System 2000 product line
Info on the Turing Lecture; here are Grady's slides
Book: Distributed Work, by by Pamela J. Hinds and Sara Kiesler (eds)
Book: Organizational Patterns by Jim Coplien and Neil Harrisson
Book: The Sciences of the Artificial, Herbert Simon
Info on the LabView toolkit from National Instruments
The approach used by Nokia for mobile phone software development
A paper describing the approach to software development by Intentional Software, Charles Simonyi

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 46: Refactoring Pt. 1

Fri, 16 Feb 2007 10:28:00 GMT

Hosts: Martin and Eberhard

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 in your everyday work. Also some advanced topics - like the ROI of Refactoring or Refactoring in dynamic languages - are covered.

Martin Fowler's site about refactoring
Refactoring to Patterns
Defintion of Refactoring at c2 Wiki
Book: Martin Fowler: Refactoring - Improving the Design of Existing Code
Book: Joshua Kerievsky: Refactoring to Patterns
Book: Lippert, Roock: Refactoring in Large Software Projects - Performing Complex Restructurings Successfully
Book: William Wake: Refactoring Workbook
Book: Scott W. Ambler, Pramodkumar J. Sadalage: Refactoring Databases: Evolutionary Database Design
Book: Michael Feathers: Working Effectively with Legacy Code
William F. Opdyke's PhD-Thesis: Refactoring Object-Oriented Frameworks
Don Roberts PhD Thesis: Practical Analysis for Refactoring (This is the PhD thesis from the work on the Smalltalk Refactoring Browser)

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 45: Round Table on Ultra Large Scale Systems

Tue, 6 Feb 2007 06:44:00 GMT

Guests: Linda Northrop, Doug Schmidt, Kevin Sullivan, Gregor Kiczales
Host: Markus
Recorded at: OOPSLA 2006

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?

In this episode, our guests discuss many of the issues that arise from this kind of system and provide an overview of the research areas that should be investigated in order to tackle the challenge. If you want to get more detailed information, you can read the ULS Report (PDF).

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 44: Interview Brian Goetz and David Holmes

Sat, 27 Jan 2007 09:46:00 GMT

Guest: Brian Goetz and David Holmes
Host: Markus
Recorded at: OOPSLA 2006

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 about thread confinement as a way of building thread-safe programs, as well as using functional programming and immutable data.
The next set of topics covers various ways of how compilers can optimize the performance wrt. to concurrency, talking about techniques such as escape analysis as well as lock elision and coarsening. We then covered how to test concurrent programs and the consequences of the Java memory model on concurrency.
We then went on to look at some more advanced topics, namely, lock-free programming and atomic variables. We also briefly discussed the idea of transactional memory.
Finally, we looked at how better language support - specifically, a more declarative style of concurrent programming as e.g. in the Fortress language - can aid in improving the quality of concurrent programs.

Brian's Homepage
The book, Java Concurrency in Practice

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 43: eXtreme Programming Pt.2

Wed, 17 Jan 2007 06:40:00 GMT

Hosts: Arno and Alex

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.

Extreme Programming Wiki
Martin Fowler's article on XP
Kent Beck, Martin Fowler: Planning Extreme Programming, Addison Wesley, ISBN 0-201-71091-9

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 42: Interview Gregor Hohpe

Sun, 7 Jan 2007 07:32:00 GMT

Guest: Gregor Hohpe
Host: Markus
Recorded at: JAOO 2006

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 and the orchestration-vs-choreography discussion. We briefly discussed the nature of pattern languages before we then went through the different section in the book. There are six main sections: channel, message, routing, transfomation, endpoint as well as management and monitoring. We discussed the core patterns for each of these sections. This should give listeners a good high-level view of message-based systems. We concluded the discussion by looking at the critical importance of systems management and monitoring.

Gregor's Homepage, his Blog
His book, also the online version

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 41: Architecture Patterns (Architecture Pt. 4)

Wed, 27 Dec 2006 06:28:00 GMT

Hosts: Michael and Markus

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.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 40: Interview Werner Vogels

Sat, 16 Dec 2006 19:28:00 GMT

Guest: Werner Vogels
Host: Markus
Recorded at: JAOO 2006

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 explained the term "pizza teams". Testing and Deployment was the next topic followed by a look at architectural characteristics of scalable systems, the value of simplicity and the CAP theorem. We concluded the discussion with a brief look at the future of distributed systems.

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 39: Interview Steve Vinoski

Wed, 6 Dec 2006 19:31:00 GMT

Guest: Steve Vinoski
Host: Markus
Recorded at: JAOO 2006

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 might be a better abstraction for distributed systems than "objects". We then covered the future of CORBA, it's use in ethe embedded space as well as the practical relevance of the POSA patterns when building ORBs. Then we switched topics and addressed the role of web services as a "middleware middleware" and the maturity of WS-* specifications. We then looked at what Steve is working on these days, which is e.g. the Advanced Message Queueing Protocol (AMQP) as well as dynamic languages. We concluded the interwiew with his view on SOA.

Steve's Blog
His Book, Advanced CORBA Programming with C++
CeltixFire Service Framework
QPid AMQP implementation
IONA's Artix ESB

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 38: Interview James Noble

Sun, 26 Nov 2006 22:53:00 GMT

Guest: James Noble
Host: Markus
Recorded at: AOSD 2006

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 know about the programmer's trade, some of our goals will have been reached.

The paper: Notes on Postmodern Programming
postmodernprogramming.org
more links...

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 37: eXtreme Programming Pt.1

Sat, 18 Nov 2006 13:48:00 GMT

Hosts: Arno and Alex

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. The second episode will continue the introduction adding the missing practices and how to introduce XP into projects.

extremeprogramming.org
xprogramming.com
Kent Beck et al: Extreme Programming Explained. Embrace Change. 1st Edition, Addison Wesley, 2000
Kent Beck et al: Extreme Programming Explained. Embrace Change. 2nd Edition, Addison Wesley, December 2004
Pete McBreen: Questioning Extreme Programming, Addison Wesley, 2002

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 36: Interview Guy Steele

Fri, 10 Nov 2006 20:15:00 GMT

Guest: Guy L. Steele Jr.
Host: Markus
Recorded at: JAOO 2006

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 to replace Fortran as a scientific computing language. We talk about how mathematical notations, syntax extensio and built-in support for parallelism are crucial properties of such a language. We then briefly talk about potentials for compiler optimization before taking a closer look at the type system (static typing, type inference), traits and contract specification as well as first-class support for hierarchical components. We conclude the discussion with a look at automatic partitioning and distribuion of concurrent algorithms and a brief look at the future roadmap for the Fortress language.

Guy's web page at Sun
There's even a Wikipedia page where you can also find a lot of information about his career and achievements
The web page of the Programming Language Resarch group at Sun
Fortress Tutorial Slides, the FAQ and the Language Spec
Wikipedia page on the Occam language mentioned in the interview
The Common Lisp book he wrote

Publicize: Digg this Post to del.icio.us Post to Slashdot

Episode 35: Roadmap

Wed, 8 Nov 2006 13:36:00 GMT

Host: Markus

This episode mainly outlines the upcoming programming and interviews.

Episode 34: Enterprise Architecture

Thu, 2 Nov 2006 13:24:00 GMT

Guest: Andy Longshaw
Host: Markus

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.

Andy's Web Site
The book on which this episode is roughly based
We mentioned the book on Security Patterns
We also talked about a paper on Service Composition by Paris Avgeriou

Episode 33: Service Oriented Architecture, Pt.2b

Mon, 23 Oct 2006 11:14:00 GMT

Hosts: Markus and Eberhard

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 integrate BPM into the conceptual SOA framework we've built up to now, and we'll also briefly skim over a number of technologies related to SOA.

Note that this episode, as well as the last one, is based on a set of slides; these can be downloaded from here. This episode covers slides 39 through 74.

Java Business Integration (JBI)
Service Component Architecture (SCA)
The Spaghetti Monster (as mentioned in the podcast by Eberhard :-))

Episode 32: Service Oriented Architecture, Pt.2a

Fri, 13 Oct 2006 04:13:00 GMT

Hosts: Markus and Eberhard

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 programming model based on the described approach typically looks like. We then discuss a number of issues any large-scale SOA faces (and for which the SOA paradigm does not really provide an out-of-the-box solution: In this episode we discuss data type ownership and (weak) typing of data types.

Note that this episode, as well as the next one, is based on a set of slides; these can be downloaded from here. This episode covers slides 1 through 38.

Episode 31: Agile Documentation

Tue, 3 Oct 2006 10:43:00 GMT

Guest: Andreas Rueping
Host: Markus

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 nice documents.

Andreas' Web Site
His book, Agile Documentation
Two of Andreas' patterns papers: The Structure and Layout of Technical Documents, Typography And Desktop Publishing. The layout and formatting of these papers nicely illustrate Andreas' very nice take on document layouting! Note that these papers serve to illustrate the layout and typography aspect - the aspect of "agile" documentation is explained in the book.
A really nice German book on typography and layout called Mut zur Typographie (yes the title is a bit strange, but the book is good!)
Another great book called Universal Principles of Design: 100 Ways to Enhance Usability, Influence Perception, Increase Appeal, Make Better Design Decisions, and Teach Through Design (yes, the title is a bit long, but the book is good!)