Software Engineering Radio - The Podcast for Professional Software Developers

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.

In this Episode, we talk to Michael Stal, a Senior Principal Engineer at Siemens Corporate Technology, POSA 1 and 2 Co-Author and Editor of the german JavaSpetrum magazine. Since Michael's core focus is middlware, much of our discussion centered around that topic. Webservices and SOA, of course, have also been covered. Other topics include Java vs. .NET as well as Patterns.

In this second part of our concurrency series Michael and Alexander talk about basic patterns for concurrent programming, such as Active and Monitor Object, Scoped Locking and Futures. Further, they discuss some architectural considerations regarding the number of threads and resource usage in general. For more information, see the references for part one as well as the following links

In this episode Michael and our guest Prashant Jain talk about patterns for resource management. Efficient management of resources is critical in the execution of any kind of software. Ranging from embedded software in a mobile device to software in a large enterprise server, it is important that the resources, such as memory, threads, file handles, or network connections, are managed efficiently to allow the systems to function properly and effectively. Michael and Prashant discuss various patterns, such as Lazy Acquisition, Caching, Leasing and Evictor and explain when, why, and how to apply them for effective resource management.

This is a short episode that outlines the upcoming episodes and interviews, as well as reports on some listener feedback.

This episode provides a hands-on guided tour through a simple model-driven software project. It is based on an actual code sample (see link below) and takes a look at the typical steps of real-life code generation: prototypical implementation, defining the metamodel, reading a model into a metamodel instance, writing templates and validating the model. The example for the episode uses openArchitectureWare as a generator environment, but the overall approach is tool independent. This episode is the first in a new category "code/technology" that discusses technical concepts based on actual code. Please give feedback whether you find this format useful or not.

A very important area for Java are Enterprise Systems. With the advent of new technologies like Ruby on Rails, Java EE 5 or EJB 3 the landscape for Enterprise Systems appears to be changing a lot at the moment. In this episode Markus talks with Eberhard about what Enterprise Java actually is, why and where it is used. Based on that they discuss what the future might look like and how to make Enterprise Java shine in the future.

In this Episode we talk to Ted Neward. Since Ted is active in the .NET and Java universes, we started out by discussing some of the differences between the two platforms. The main discussion, however, focussed on new features in the C# 3.0 language. These include LINQ (language-integrated query). A very interesting discussion about extension methods, lamda expression, typing (dynamic, duck, compiler) and other language "tricks" follows. We also visited the topic of language development on the .NET and Java platforms in general, also looking at topics such as concurrency and the Scala language.

Ruby has been getting more and more attention by the developer community over the last couple of years. Nevertheless Ruby as language and as a plattform is not too widespread. Most developers don't know people who have actually done commercial Ruby projects. Therefore it is sometimes hard to judge if Ruby is just a hype topic or if Ruby can be used for serious projects today. In this episode Alexander speaks with Thomas Quas about a commercial Ruby project Thomas finished a while ago. Thomas shares his insights and practical experiences with Ruby doing a project under strong time pressure. As Thomas has many years experience doing Java projects we also do some high level comparisons between both platforms.

This is the first part of a series of Concurrency episodes. In this part Alex and Michael motivate and introduce the topic. We explain fundamental terms, such as thread, process, or mutex and dicuss typical challenges, such as deadlocks and race conditions.

In this Episode we have the pleasure of talking with Gregor Kiczales. Gregor is one of the fathers of aspect-oriented programming (AOP). Today he is a professor of computer science at the University of British Columbia. Back in his days at Xerox Parc, he and a number of other people worked on the early forms of AOP as well as on some of its forerunners, such as meta object protocols. In this interview, we talk about a number of interesting topics, such as the history of AOP, the relationship of AO to interceptors, the industry acceptance of AOP, early aspects (i.e. using AO in development phased before implementation) as well as adoption strategies for AOP.

This is the second part of the remoting infrastructures discussion started in Episode 9. We take a look at how remoting infrastructures such as CORBA, .NET Remoting or Web Services work internally. This includes the low level details of the transport layer, marshalling, client proxies as well as interceptors and asynchronous communication. At the end, Michael will explain how all this relates to CORBA and Markus will map the concepts to .NET remoting. We don't have additional links in these show notes since all the relevant links had been posted for Episode 9 already.

This Episode as well as the next one take a look at remoting infrastructures such as CORBA, .NET Remoting or Webservices. In this first part we will take a look at why remote communication is necessary in the first place, what remoting middleware can do for you as well as which other middleware technologies exist in addition to OO-RPC systems, such as messaging middleware. Finally, we conclude with a brief overview of what the broker pattern can do for us in the context of remoting middleware.

Eric Evans is the author of the well known Domain-Driven Design book. In his day job he works as a consultant and coach for his own company, Domain Language. In this interview, Eric talks about the essential building blocks of domain-driven design as well as about a set of best practices on how to address complex projects. In a third part, he elaborates on the relationship of domain-driven design and MDSD/MDA.

This week, Arno and Markus take a look at error handling at the architectural level. They discuss the different kinds of errors, the groups of people who need to know about them and proven high-level approaches. Later episodes will investigate more technical aspects of error handling, such as idioms for using exceptions or a discussion of checked vs. unchecked exceptions.

After discussing some of the more technical aspects of MDSD in the last episode, we take a look at other important topics in this one. This includes some tips on how to introduce MDSD into projects and how the development process has to be adapted for this to work, as well as a look at the return on investment for MDSD. The relationship of MDSD and Agile software development is also discussed. Finally, we take a look at offshoring in the context of MDSD.

In this Episode, Eberhard and Markus provide an introduction to Model-Driven Software Development. Since the discussion turned out to be too long, we separated things into two episodes, thus Episode 6 will be the second part of this discussion. In this first part we disucsss core concepts of MDSD, the relationship to MDA, and hint at a couple of tools.

In this Episode, Alexander and Markus talk about scripting languages. Topics include the definition of what a scripting language is, typical usage scenarios, performance issues, programming styles and IDE support. In later Episodes we will talk about more specific topics, such as dynamic typing, reflection, functional programming as well as specific languages such as Ruby.

In this episode we talk with Doug Schmidt. Doug is a professor of computer science at Vanderbilt University and a well-respected authority in the fields of middleware, patterns and model-driven development. In this interview we talk about these topics in the context of distributed, realtime embedded (DRE) systems.

Eberhard and Markus discuss the important topic of associations and dependencies in this show. While OO languages provide direct support for subtyping, most don't provide a first-class construct for other relationships between objects. The discussion elaborates on the problem and looks at various remedies, most importantly, dependency injection.

In this episode Michael and Markus talk about patterns. Starting with some of their "most used" patterns, they go into some detail about the history of patterns. They then discuss the various pattern forms as well as some misconceptions about patterns. Other topics include the domains that are covered by patterns as well as pattern languages.

This is the first episode (actually, episode zero) of software engineering radio. The episode does not contain real content, rather, Markus explains what the podcast is all about.