In 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 why this is important to concurrency) and pattern matching. Next we discussed how to implement distribution and fault tolerance, and we took a look at OTP, the "application server" for Erlang. We concluded the conversation with a littel discussion about how Erlang was designed, it's current community as well as its future.

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

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

In 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 as well, which in turn influences the development effort as a whole.

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

In 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 they are suitable for open source business. We concluded the episode by discussing a couple of specific questions and loose ends. After the show, Dirk informed me about the following three corrections: Black Duck Software's main product is called protexIP not IP Central, there are presently 70 licenses approved by the Open Source Initiative, and EnterpriseDB has so far acquired $37M in venture capital

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

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

In 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 the future, static vs. dynamic typing, functional programming, meta programming as well as the importance of good support for concurrency. We concluded the discussion by looking at the interplay between languages and IDEs.

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

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

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

In 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 of delta debugging and the relationship to other means of automatically finding problems in software.

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

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

In 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 to use plugins for implementing software systems.

In 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 improvement and CMM. At the end of the interview we talk a little about Linda's current interest: how does the brain work?

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

This 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 and I briefly discuss our common passion, gliding :-)

We start our discussion with a brief look at what Haskell is and how a pure functional language is different from non-pure languages. We then look at the basic building blocks and the philosophy of the language, discussing concepts such as the lambda calculus, closures, currying, immutability, lazy evaluation, memoization, and the role of data types in functional languages. A significant part of the discussion is then spent on the management of side effects in a pure language - in other words, the importance of monads. We conclude the episode with a look at Haskell's importance and community today.

In this episode we discuss with Randy Shoup, Distinguished Architect at eBay, about architectural pinciples and patterns used for building the highly scalable eBay infrastructure. The discussion is structured into four main ideas: partition everything, use asynchrony everywhere, automate everything, and design the system keeping in mind that everything fails at some point in a large distributed system.

This is the first part of a two part topic on roles in software engineering. Michael and Markus discuss role definitions in an corporate environment. For several typical roles we give hints on the expected skills, knowledge, and mindset. In this episode we discuss the roles junior developer, senior developer, and software architect.

In this episode we discuss the status of SE Radio today and introduce the team members. Among other things, Markus discusses stats, sound quality, partners, transcripts, and the cooperation with Hillside Europe. Also, the team members introduce themselves with a one to two minute clip.

This is the second part of the two part topic on roles in software engineering. Michael and Markus discuss role definitions in a corporate environment. For several typical roles we give hints on the expected skills, knowledge, and mindset. In this episode we discuss the roles technical lead, technologist, requirements engineer, product manager, and project manager.

In this episode we talk with Jeff McAffer about building platforms. We start with a brief discussion about what a platform is in contrast to a framework or an application. Drawing from his experiences working on the Eclipse platform for years, Jeff talks with us about how to develop platforms, why developing a platform is different from developing an application, what makes a good platform great, and why API design becomes so extremely important for platforms. He provides us with some insights on how the development process and the client collaboration for platform development could look like and what has and has not worked in the past.

In this episode we talk to Christof Ebert about requirements engineering. As the name "engineering" suggests, we need to be systematic when working and managing requirements. Christof will structure RE into several activities, namely elicitation (identifying the relevant requirements), specification (clearly describing requirements), analysis (synthesizing a solution), verification and validation (achieving good requirements quality), comittment (allocating requirements to a project, product release or iteration), and management (keeping track of the implementation status of requirements). In this episode we discuss these activities and highlight lots of practical guidance.

During Evolution of a software system, it becomes more and more difficult to understand the originally planned software architecture. Often an architectural degeneration happens because of various reasons during the development phases. In this session we will be looking how to avoid such architectural decay and degeneration and how continuous monitoring can improve the situation (and avoid architectural violations). In addition we will look at "refactoring in the large" and how refactoring can be simulated. A new family of "lint like tools for software architectures" is currently emerging in the marketplace I will show some examples and how they scale and support you in real world projects.

In this episode we're talking to James A. Hendler about the semantic web. We start with a definition of the semantic web and by discussing the main ingredients. We then look at (more or less) related topics such as prolog, artificial intelligence, wisdom of the crowds, and tagging. In the next section we discuss the core semantic web technologies: RDF, OWL, inference engines, SPARQL, and GRDDL. We conclude our discussion by looking at the status of the semantic web today and a couple of example applications.

In this episode we're talking to Bran Selic of Malina Software about modelling in general and UML2 in particular. Bran covers the basics of modelling, the history of UML, and what's new in UML2.

In this episode we're talking to Eelco Visser about parsing text. We start at the basics - what is parsing? - covering classic tools such as Yacc and classic parsing approaches such as LALR before examining how more recent approaches such as scannerless parsing can make parsing easier and enable previously impractical use cases.

In this episode, Markus talks with Juha-Pekka Tolvanen about using DSLs and code generation in practice. The main part of the episode is the discussion about a number of case studies that show how DSLs and code generation are used in practice.

In this episode we're talking to Anneke Kleppe about model-driven software development and language engineering. We start with her involvement in the creation of the Object Constraint Language (OCL) and discuss the intial expactations, actual experiences, and the place of OCL in the current day. From here, Anneke talks us through her take on the formative years of UML and MDA. From here, we expand to the realm of Domain-Specific Languages and Anneke discusses their place in software engineering in general and why we should expect DSLs in significant numbers to become a common sight.

In this episode, Michael Plöd is interviewed about Object-Relational Mapping technology. He talks about the common concepts, compares the range of different tools that go by this name, and goes into the design and architectural consequences of using an OR mapper.

This is a discussion with Janos Sztipanovits about Cyber Physical Systems and how DSLs are used to approach some of the challenges in that domain. Specifically, in the second part we talk about formalizing DSL semantics.

In this episode we discuss Microsoft's OSLO platform with Doug Purdy and Don Box. We briefly discuss what OSLO is in general and then look at the various components of OSLO. We also look at how OSLO fits in with the general Microsoft strategy and how it compares to other DSL/Model-driven approaches. We then look at language modularization and composition and discuss the similarities with XML and Smalltalk. Finally, we discuss possible integrations of OSLO with other MD* approaches and technologies.

In this episode we look at SUN's open source strategy for the OpenJDK. We discuss challenges in creating such a big open source project, and ways to keep it focused and organized. We discuss what it means for the Java runtime to be adopted as the technological foundation for other programming languages.

In this episode Martin talks with Chris Grindstaff about the fundamentals of performance engineering. The episode discusses when and how to work on performance of client- and server-side systems, what you should take into account during development to avoid performance issues, typical situations that cause performance problems, and some common pitfalls when analysing performance.

In this episode we take a brief look at Jetbrains' Meta Programming System, a language workbench for creating external DSLs or for extending existing languages (such as Java). In a brief telephone discussion, Konstantin Solomatov explains what the system does and how it works. The system has recently been released into public beta and will be made available under then Apache 2.0 Open Source license.

This episode is an introduction to user interface design with Joachim Machate of UID. We talk about the importance of user interface design, about its relationship to the overall software engineering process, as well as about UID's process for systematic user interface design.

The majority of hacker attacks (70 %) are directed at weaknesses that are the result of problems in the implementation and/or architecture of the application. This session shows how you can protect your web applications (J2EE or .NET) against these attacks. The session covers lots of practical examples and techniques for attack. Furthermore, it shows strategies for defense, including a "Secure Software Development Lifecycle". A "Live Hacking" demo rounds it out. This is a session recorded live at OOP 2009. SE Radio thanks Bruce, SIGS Datacom and the programme chair, Frances Paulisch, for their great support!

This episode is a discussion about F# with Microsoft's F# program manager Luke Hoban.

This episode is a discussion about code and metrics visualization with Michele Lanza. Michele invented the Code Cities idea about which he talks in this episode.

This episode is an interview with Tom DeMarco and Peter Hruschka about the new book of the Altantic Systems Guild: Adrenaline Junkies and Template Zombies: Understanding Patterns of Project Behavior. This is a session recorded live at OOP 2009. SE Radio thanks Tom and Peter, SIGS Datacom and the programme chair, Frances Paulisch, for their great support!

This is a discussion with Eoin Woods about his collection of top 10 software architecture mistakes. Looking at things that don't work is always a good way to learn what you should actually do.

In this episode Markus discusses with Chris Read basics and some advanced topics in the space of continuous integration. We cover concepts, some tools, as well as a number of best practices.

This episode is a discussion with Michael Nygard about his book "Release It" which covers aspects of software architecture you often don't think of initially when starting to build a system. Some of the points we discussed were capacity planning, recovery as well as making the system suitable for operation in a data center.

In this episode Michael interviews one of our regular listeners: Petri Ahonen. Petri introduces Software Configuration Management by defining key terms and describing relevant concepts.

In this episode, Dirk talks with David Frankel, resident Metamodeller and MDA expert at SAP Labs LLC, SAP's subsidiary in the Silicon Valley. Dave's extensive experience provides a big picture, from the early days of CORBA all the way to current issues that are bugging most enterprise architects' work with MDA.

In this episode, Arno talks to Jim Melton about the SQL programming language. In addition to covering the concepts and ideas behind SQL, Jim shares stories and insights based on his many years' experience as SQL specification lead.

In this episode, Allan shares his insights about how learning is a necessary part of software development. He covers the personal as well as the team and the organizational level and offers practical advice.