Tag: Technology Talk

In this espisode we take a closer look at relational database systems and the concepts behind them. We start by discussing the relational paradigm, its concepts and ramifications, and go on to architectural aspects.

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.

This episode is an introduction to embedded system. It is an introduction in the sense that we cover many topics very briefly: upcoming episodes will provides details for many of these topics.
We start by discussing what an embedded system is an what the important characteristics are. Among them is limited resources, concurrency, real time and hardware integration. We also discuss the range of embedded systems from small mirocontrollers to mobile phones to distributed real time embedded systems. We also cover the different business case for embedded systems (per unit cost) and some non-trivial developmental aspects (cross compilation debugging, heisenbugs).
We close the episode by discussing some important architectural styles (time triggered, event-based, microkernels, state machines) as well as tools of the trade: languages, operating systems and middleware.

Variability is one of the key concerns in software product line engineering. The episode introduces the concepts of structural and non-structural (or configurative) variability. It also discusses how to find and model variability, and especially how to implement variability in the solution artifacts. Michael and Markus discuss a series of variability mechanisms that can be used with today’s programming languages and technologies.

In the first episode on Refactoring we talked about the basic ideas behind refactoring and some base principles why refactoring is a key part of software engineering. Now we move on to more complicated refactorings and discuss three major situations, their problems and possible solutions: advanced refactorings in large projects that can hardly be finished in a few minutes or hours and refactoring in larger teams. Also covered are the refactoring of published APIs and how merciless refactoring could be aligned with backward compatibility of published APIs, and refactorings that affect more than just code like for example database schemas.