Residential gas furnaces must all have a minimum AFUE of 95% beginning in five years. Some in the HVAC industry say the new Department of Energy rule will ultimately hurt homeowners.

Due to a lack of training, time constraints, and numerous other reasons, many HVAC contracting companies are not performing combustion testing, potentially compromising customers’ safety.

Taking a look at the major concerns around replacing an 80% furnace with a high-efficiency one such as venting requirements, drilling extra holes, and financial costs.

For technicians who run across older furnaces where air conditioners were later added, it pays to know how a fan center operates.

The residential heating showcase is designed to help HVAC contractors learn about the new heating equipment that is available for the upcoming cooler months.

A homeowner in Pickering, Ontario works with an experienced HVAC pro to improve comfort, efficiency, and energy savings with a high-efficiency hydronic forced-air furnace upgrade.

Posted by Ciro Santilli OurBigBook via dev on Sep 17

Posted by Vladimir Soldatov on Sep 17

Posted by CISA on Mar 21

Posted by Dave Aitel via Dailydave on Nov 02

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.

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.

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.

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.

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.

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.

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 Episode, Arno, Bernd and Markus interview Jutta Eckstein. Jutta is a pioneer and expert on using Agile software development, specifically in larger teams. In the interview we talk about the agile manifesto, the role of personal relationships and trust in software projects, differences between agility in the small and in the large, as well as offshoring.

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.

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.

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.

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

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.

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

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

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.

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.

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

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

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.

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.

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?

This episode is a conversation with Erich Gamma. We covered the four things he is known for in chronological order. We started with design patterns and the Gang-of-Four book of which he is the lead author. We then looked at JUnit, the testing framework he coauthored with Kent Beck and how it introduced unit testing to the masses. The next topic is obviously Eclipse, where Erich and his lab in Zürich is responsible for the Java Development Tooling. We also briefly discussed The Eclipse Way, the (obviously) successful process the Eclipse team uses for developing Eclipse itself. Finally, we're looking at Erich's current endeavour, the Jazz project. Jazz is a technology for collaborative software development.

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.

This episode is an interview with Dave Thomas (OTI Dave or Smalltalk Dave, not PragDave). We started our discussion with a look at the (non-)success of objects and components. We then discussed some history behine Eclipse and Dave's role in OTI. We then compared Smalltalk and Ruby and looked at the promises of small and powerful languages such as Lisp. We also discussed the role of (static) type systems and the role of tool support for languages. We then switched gears and looked at what is necessary to scale agile development to the level of large organizations and how techniques from lean production and manufacturing as well as product management can play an important role. In the last part of the interview we looked at the state of research today, and especially the relationship between industry and academia in this area. We concluded the interview with Dave's opinion on what it takes to be a good developer.

In this episode, Michael and Markus talk about software components. We first looked at a couple of attempts at defining what a component is. We then provided our own definition that will be used in the rest of the episode. We then looked at the promises of component-based development: why are components useful? We then discussed some of the typical metadata components should specify to make them useful. We discussed to some extent typical variations in component models. The next topic was the separation of concerns between the component functionality and functionality provided by the component's execution environment (aka. container). We then compared components with other (more or less) related technologies such as OO and SOA. We concluded the episode with the notion of architecture as language, where you use a formal DSL to describe a system's architecture. Components are the basic building block for this approach.

In this episode we talk to Galen Hunt about the Singularity research OS. Galen is the head of Microsoft's OS Research Group and, together with a team of about 30 other researches, has built Singularity. We started our discussion by covering the basics of Singularity: why it was designed, what the goals of the project are as well as some of the architectural foundations of Singularity: software isolated processes, contract-based channels and manifest-based programs. In this context we also looked at the role of the Spec# and Sing# programming languages and the role of static analysis tools to statically verify important properties of a singularity application. We then looked a little bit more closely at the role of the kernel and how it is different from kernels in traditional OSes. In a second part of the discussion we looked at some of the experiments the group did based on the OS. These include compile-time reflection, using hardware protection domains, heterogenerous multiprocessing as well as the typed assembly language We closed the conversation with a look at some of the performance characteristics of Singularity, compatibility with traditional operating systems and a brief look at how the findings from Singularity influence product development at Microsoft.

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, 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'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 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?