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

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.

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 :-)

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.

This is another episode where we mainly announce topics related to the podcast itself.

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.

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.

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

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

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.

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

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.

In this Episode we discuss fault tolerance based on the new book by Bob Hanmer. This is the actually the first part of the discussion, the remainder will be published in the next episode of SE Radio. We start by discussing some of the context for fault tolerant systems and the imperfect world assumption. We then discuss a number of terms we will need when discussing the fault tolerance patterns. We then discuss the fault tolerance mindset and connect fault tolerance to a number of related subject areas, such as software quality. We then discuss the shared context for the patterns that follow, among them the important observation that fault tolerance does not come for free! Finally we provide an overview over the different sections covered in the book and start the detailed discussion of the patterns by looking at the Architectural Patterns section. The next episode will discuss the remaining patterns in the book.

This is the second part of the discussion on fault tolerance with Bob Hanmer (if you didn't listen to Episode 77, which contains part one, please go back and listen now; this episode builds on that previous one!) We start by discussing a set of error detection patterns. Among are the well-known approaches such as checksums and voting. We then look at error recovery patterns, including restart, rollback or roll forward. The next section looks at error mitigation patterns, which include shedding load and doing fresh work before stale. The last patterns section then looks at fault treatment patterns. We conclude the episode with a small discussion about how to design systems using (these and other) patterns, and with some thoughts on why actually wrote the book.

In this Episode we're discussing patterns for small memory software with the authors of the like-named book Charles Weir and James Noble. We look at various aspects of the small memory problem: How can you manage memory use across a whole system? What can you do when you have run out of primary storage? How can you fit a quart of data into a pint pot of memory? How can you reduce the memory needed for your data? How do you allocate memory to store your data structures? Answers to all those questions are provided in this Episode, and of course in their book.

This episode is about OSGi, the dynamic module system for Java. Our guests are Peter Kriens (OSGI's Technical Director) and BJ Hargrave (OSGI's CTO). We'll discuss what OSGi is all about and why and in which contexts it is useful. Additionally we are having a look at the different layers of OSGI and where and how they are used. Other questions discussed are: What means dynamicity in an OSGI environment? Where is OSGI used? What’s the future of OSGI? How does OSGI interact with existing middleware solutions? How can I run several versions of the same JAR at the same time? Where are OSGI’s problems?

In this episode Eberhard Wolff speaks with Jürgen Höller, the co-found of the Spring framework. Spring is a tremendously successful Java framework so they discuss the design of large frameworks and the issues that arise in the evolution. Jürgen explains the management of dependencies in the framework, how to structure such a framework, how to offer compatibility for the existing user base while evolving the framework and the role of metrics during development.

In this Episode we're talking about Web Services with IBM's Olaf Zimmermann. We mainly focus on the WS-* stack. We also discuss a couple of SOA foundations and architectural decisions that need to be taken when building an SOA using Web Serivces. We also briefly mention the REST vs. WS-* debate.

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

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

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.

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

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 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 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!

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

This episode is once again with Linda Rising, this time on the book she coauthored with Mary Lynn Manns on introducing ideas into organizations. The talk is another one of the SE Radio Live sessions recorded at OOP 2009 - thanks to SIGS Datacom and programme chair Frances Paulisch for making this possible.

This episode is a conversation with Gilad Bracha about Newspeak, type systems in general and optional/pluggable types in particular. It was recorded during DSL Devcon in the gardens of the Microsoft campus, and thanks to Gilad's "speaking like a book" way of talking it is published completely unedited :-)

In the first part of this episode we discuss a couple of basics about SecondLife (scaling, partitioning, etc). The second part specifically looks at how the dev team tackled a number of interesting problems in the context of executing their own LSL scripting language on top of Mono.

This is another episode recorded at OOP 2009, thanks to SIGS Datacom and programme chair Frances Paulisch for making this possible. Here is the abstract from the conference program: Many software systems have fragile architectures that are based on brittle assumptions or rigid architectures that reduce options and make change difficult. On the one hand, an architecture needs to be fit for the present day, suitable for immediate use, and on the other it needs to accommodate the future, absorbing reasonable uncertainty. However, an approach that is overly focused on today's needs and nothing more can create an inflexible architecture. An approach that becomes obsessed with possible future changes creates an overly complex architecture that is unfit for both today's and tomorrow's needs. Both approaches encourage an early descent into legacy for a system. The considerations presented in this talk reflect an approach that is more about thinking in the continuous present tense than just the present or the future tense. This includes principles from lean thinking, practices common in agile processes and techniques for loosely coupled design.

Michael and Markus discuss what makes a good R&D manager and how to potentially become an R&D manager. You will learn what some of the essential skills are, what the challenges are, and what the 'mission/vision/strategy thing' is actually good for.

Michael discusses with his guest Chuck Connell the differences between software engineering and computer science. What makes software engineering so unpredictable, with so few formal results? And how can we advance the field of software engineering without these results?

This episode is a conversation with "Uncle Bob" Bob Martin about agile software development and software craftsmanship specifically. We talk about the history of the term, the reasons for coming up with it some of the practices and the relationship to other agile approaches. We conclude our discussion with an outlook on some of todays new and hyped programming languages.

This episode is a discussion with Shane Clifford, who is a development manager at Intentional Software. We discuss the idea behind intentional programming, key concepts of the technology as well as example uses and a little bit of history.