What are the most common mistakes in heat pump installs, and how do you avoid them? Here’s what experts had to say about heat pump installation — a must-watch as electrification continues to gain momentum.

The equipment in this month’s troubleshooting problem is an electric furnace that has been in service for at least ten years and has no service history.

Cold climate heat pumps were on full display on the AHR show floor and manufacturers were eager to share their progress reports in the Department of Energy’s CCHP Challenge.

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.

Posted by Ciro Santilli OurBigBook via dev on Sep 17

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

This is the first of two episodes where Arno and Alex discuss eXtreme Programming in se-radio's development process track. eXtreme Programming (XP) revolutionized the way of thinking about software development methodologies and helped to make the agile movement popular. In this episode they discuss the very basics of XP, its value system, principles and the basic practices used in an XP project. The second episode will continue the introduction adding the missing practices and how to introduce XP into projects.

This is the second part of our two part discussion of the eXtreme Programming development methodology. While the first part introduced the values, principles and basic practices, this time Arno and Alex speak about the practices that set the context for an XP project and how to get started, and they discuss some FAQs they often get when introducing XP.

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 episode is about compile-time metaprogramming, and specifically, about implementing DSLs via compile-time metaprogramming. Our guest, Laurence Tratt, illustrates the idea with his (research) programming language called Converge.

We started by talking about the importance of a custom syntax for DSL and took a brief look at the definition of DSLs by a chap called Paul Hudak. We then briefly covered the disctinction between internal and external DSLs.

More to the point of this episode, we discussed the concept of compile-time metaprogramming, and the language features necessary to achieve it: in converge, these concepts are called splice, quasi-quote and insertion. We then looked at how the Converge compiler works, and at the additional features that are required to implement DSLs based on the metaprogramming features mentioned above. Using an example, we then walked through how to implement a simple DSL.

Looking at some of the more technical details, we discussed the difference between the parse tree and the abstract syntax tree and at different kinds of parsers - specifically, the Earley parser used by Converge. In multi-stage languages (i.e. languages that execute programs and meta programs) error reporting is important, but non trivial. We discussed how this is done in Converge. We finally looked at how to integrate Converge's expression language into your DSL and how to package DSL definition for later use.

The last segment look at the process of implementing a DSL in converge and about some of the history and practical experience with Converge. Lessons learned from building Converge wrap up the episode.

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

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.

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

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.

Our guest Johan Bezem explains the idea behind and the benefits of MISRA. MISRA defines guidelines for C and C++ programming in order to ensure quality. While it got started for embedded automotive development, it is more generally applicable.

Recording Venue: Skype Guest: Michael Hunger Michael Hunger of Neo Technology, and a developer on the Neo4J database, joins Robert to discuss graph databases. Graph databases fall within the larger category of NoSQL databases but they are not primarily a solution to problems of scale. They differentiate themselves from RDBMS in offering a data model built […]

Recording Venue: Skype Guest: Michael Stonebraker Dr. Michael Stonebraker, one of the leading researchers and technology entrepreneurs in the database space, joins Robert for a discussion of database architecture and the emerging NewSQL family of databases. Dr. Stonebraker opens with his take on how the database market is segmented around a small number of use […]

Robert talks to Dr. Anil Madhavapeddy of the Cambridge University (UK) Systems research group about the OCaml language and the Mirage cloud operating system, a microkernel written entirely in OCaml. The outline includes: history of the evolution from dedicated servers running a monolithic operating system to virutalized servers based on the Xen hypervisor to micro-kernels; […]

Charles Anderson talks to Mitchell Hashimoto about the Vagrant open source project, which can be used to create and configure lightweight, reproducible, and portable development environments. Vagrant aims to make new developers on a project productive within minutes of joining the project instead of spending hours or days setting up the developer’s workstation. The outline […]

Micro services is an emerging trend in software architecture that focuses on small, lightweight applications as a means to avoid large, unmaintainable, monolithic systems. This approach allows for individual technology stacks for each component and more resilient systems. Micro services uses well-known communication schemes such as REST but also require new technologies for the implementation. […]

Johannes Thönes talks to James Lewis, principal consultant at ThoughtWorks, about microservices. They discuss microservices’ recent popularity, architectural styles, deployment, size, technical decisions, and consumer-driven contracts. They also compare microservices to service-oriented architecture and wrap up the episode by talking about key figures in the microservice community and standing on the shoulders of giants. Recording […]

Grant Ingersoll, founder and CTO of LucidWorks, talks with Tobias Kaatz about his book Taming Text: How to Find, Organize, and Manipulate It. They begin by discussing popular existing systems for the automated understanding of contextual information. One such system, IBM Watson, drew attention for its victory in the “Jeopardy” game show. They proceed to […]

Mike Barker talks with Sven Johann about the architecture of the LMAX system. LMAX is a low-latency, high-throughput trading platform. Their discussion begins with what LMAX does; the origins of LMAX; and extreme performance requirements faced by LMAX. They then delve into systems that LMAX communicates with; LMAX users; the two main components of the system (broker and exchange); Mechanical Sympathy as an architectural driver; message flow using the Disruptor library; and lock-free algorithms. Mike and Sven wrap up by discussing how a well modeled domain model can improve the performance of any system; automated (performance) tests; continuous delivery; and measuring response times.

Michael Nygard of “Release It!” fame talks with Stefan Tilkov about his experience using the Clojure programming language. Topics include the tool chain and development process, the Clojure learning curve, and on-boarding new developers. Michael explains the similarities and differences compared to typical OO languages when implementing domain logic, and uses both game development and typical web development projects as examples. Finally, the two discuss how well Clojure can be used in the face of long-running projects, and some typical obstacles and strategies for introducing it to real-world scenarios.

Stefan Tilkov talks to Camille Fournier about the challenges developers face when building distributed systems, whether the can avoid building them at all, and what changes occur once they do.

Johannes Thönes talks to Patrick Kua about the role of a technical lead and how to become one. The show starts with introducing the concept of a lead and contrasts the lead role with other roles, such as technical manager, architect and senior developer.  The discussion continues to the responsibilities of a tech lead (supporting engineering practices, managing, resolving conflict, and growing people). The discussion continues on to talk about the challenges of becoming a tech lead and how to overcome them and closes with the question: “how can you tell if you are succeeding as a tech lead”?

Felienne talks with Peter Hilton on how to name things. The discussion covers: why naming is much harder than we think, why naming matters in programming and program comprehension, how to create good names, and recognize bad names, and how to improve your naming skills.

James Turnbull joins Robert Blumen for a discussion of Terraform, an infrastructure-as-code tool, and a deep dive into how Terraform implements the declarative programming model.

Felienne talks with Michael Feathers about Legacy Code. When is something legacy? Is working on legacy different from working on greenfield code? Do developers need different skills and techniques? Testing legacy code. How to test a legacy system? When do we have enough tests to feel safe to start coding? Techniques to make legacy systems more testable.

Kirk Pepperdine talks with Diomidis Spinellis about performance optimization. Topics include development practices, tools, as well as the role of software architecture, programming languages, algorithms, and hardware advances.

Edaena Salinas talks with Nicole Hubbard at KubeCon 2017. They discuss why WP engine is migrating from VMs to Kubernetes and how the migration is structured. Nicole explained the VM infrastructure at WP Engine and why there was a need to move...

Dmitry Jeremov and Svetlana Isakova speak to Matthew Farwell about the Kotlin programming language.

Travis Kimmel and Kevin Goldsmith discuss the correspondence between organizational design and software architecture. Their conversation covers: what Conway’s Law is; Kevin’s experiences in different organizational structures (e.g., Avvo, Spotify, Adobe, and Microsoft) and how those structures influenced the software architecture; what the “Reverse Conway Maneuver” is and how organizations can leverage it; how organizations can evolve existing architectures.

Jeremy Jung talks with David Calavera about zero-downtime migrations and rollbacks with Kubernetes. In this episode we define migrations, rollbacks, and discuss how Netlify was able to migrate to Kubernetes and roll back off of it multiple times without impacting their users. David explains how developers can run old and new systems simultaneously, the importance of defining errors in your system, and when to apply fixes vs rolling back. We also discuss their decision to move to Kubernetes, and the benefits they received.

Michael Hausenblas talks with host Kim Carter about topics covered in Michael’s ebook Container Networking, such as single vs. multi-host container networking, orchestration, Kubernetes, service discovery, and many more. Michael and Kim also discuss the roles that IPTables plays, how the allocation of IP addresses is handled, along with the assignment of ports. Overlay networks are covered along with topics such as the open Container Network Interface (CNI).

Edaena Salinas talks with Stephen Ewen about streaming architecture. Stephen is one of the original creators of Apache Flink. Topics discussed: stream processing vs batch processing, architecture components of stream architectures, Apache Flink...

Bernd Rücker, who has contributed to multiple open source workflow management projects, discusses orchestrating microservices with workflow management.  As distributed systems evolve into a family of microservices that must handle long-running stateful processes with time-dependent actions, events, multiple paths through the system, and complex rollbacks, the workflow management model provides a way to ensure clear modeling, correctness, and separation of concerns.   Rücker recommends a federated model in which each microservice is paired with its own workflow to handle retries and other policies and failure modes around that service.  Robert Blumen spoke with Rücker about microservice architecture, event-driven systems, long-running stateful processes versus synchronous request/response, event handling, time-outs, and handling exceptional conditions with compensating transactions. Rücker compares the choreography versus orchestration models for collaboration and discusses why orchestration provides a better separation of concerns.  The discussion delves into the implementation of workflow management systems including persistence, scaling, event handling, timers and scheduling, and similarities to CQRS.  The discussion wraps up with monitoring and visualization.

Felienne talks to Diomidis Spinellis about different forms of debugging. From using print-statements to version-control systems and operating system tools. We also discuss debugging strategies for different types of programming systems.

The use of distributed and remote software teams have grown dramatically in the past five years, presenting new challenges for managers and engineers alike. Bryan Helmig talks about the best practices his company, Zapier, uses to manage remote software...

Chris Richardson of microservices.io and author of the book Microservice Patterns discuss microservice patterns which constitute a set of best practices and building-block solutions to problems inherent microservice architecture.

Michael Chan has been teaching React since 2013 and is the host of the React Podcast. He currently works at Ministry Centered Technologies as a Frontend Architect.

Pat Helland talks to host Akshay Manchale about Data Management at scale in a Microservices world. Pat talks about trends in managaging data in a distributed microservices world, immutability, idempotence, inside and outside data, descriptive...

Sumit Kumar, Head of Engineering at SHARE NOW talks with Jeremy Jung about creating mapping applications in JavaScript using the Leaflet library.

Michaela Greiler spoke with SE Radio’s Felienne about code review best practices and how to improve the effectiveness of your reviews.

Jeremy Miller, Senior Software Architect at Calavista Software, compares and contrasts his experiences with waterfall and agile methodologies. Host Jeff Doolittle spoke with Miller about the history of these methodologies and how teams can experience...

Felienne spoke with Mike McCourt on difficulties in processing voice data using machine learning.