Software Engineering Radio - the podcast for professional software developers

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

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

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.

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.

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.

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

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.

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.

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.