Software Engineering Radio - the podcast for professional software developers
Alle afleveringen
750 afleveringen, van nieuw naar oud
-
Episode 99: Transactions
31 mei 2008 · 1 uur 1 min
This episode takes a close look at transactions from different angles, starting with their fundamental properties of Atomicity, Consistency, Isolation, Durability but also investigating advanced topics like distributed or business transactions.
-
Episode 98: Stefan Tilkov on REST
23 mei 2008 · 56 min
In this episode we discuss REST (Representational State Transfer) with Stefan Tilkov. We started out by discussing the 5 steps to REST: IDs, links, Standard Methods, multiple representations and stateless communication. We then looked at how to use HTTP for REST, and discussed about how to use it for Web Services. We then we discussed whether and how to use REST for enterprise applications, and not just for apps on the internet. We concluded the discussion with a couple of recommendations. Lees meer
-
Episode 97: Interview Anders Hejlsberg
16 mei 2008 · 48 min
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. Lees meer
-
Episode 96: Interview Krzysztof Czarnecki
8 mei 2008 · 33 min
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. Lees meer
-
Episode 95: The New Guardian.co.uk website with Matt Wall and Erik DoernenBurg
1 mei 2008 · 44 min
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. Lees meer
-
Episode 94: Open Source Business Models with Dirk Riehle
23 april 2008 · 1 uur 4 min
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 Lees meer
-
Episode 93: Lessons Learned From Architecture Reviews with Rebecca Wirfs-Brock
15 april 2008 · 52 min
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.
-
SE Radio 92: Introduction to Game Development with Oliver Jucknath
7 april 2008 · 49 min
In this Episode, Arno talks with Oliver Jucknath about the art of writing computer games. A lot of myth is attached to this area of computing, and while a game technically is just another program, it is written in a different context than typical business applications. This is true at the code level, where aggressive optimization is a focus throughout development. It also applies at the team level, where collaboration between specialists is pronounced. And the business context is different as well, which in turn influences the development effort as a whole. Lees meer
-
Episode 91: Kevlin Henney on C++
30 maart 2008 · 1 uur 4 min
In this episode, we talk with Kevlin Henney about the C++ programming language. We look at the history and the culture of the language, and how it went through several phases in its evolution. We also take a look at some of the special language features of C++ and their overall influence. Lees meer
-
Episode 90: Product Line Engineering, Pt. 3, with Charles Krueger
22 maart 2008 · 37 min
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. Lees meer
-
Episode 89: Joe Armstrong on Erlang
12 maart 2008 · 53 min
In this Episode we're talking about Erlang with its creator Joe Armstrong. We started by looking at the history of the Erlang language and why it is so relevant today. We then looked at Joe's approach to Concurrency Oriented Programming and its main ingredients: share nothing, lightweight concurrency and pure message passing. We also compared this to the classic shared memory approach to concurrency. We then looked at other interesting aspects of Erlang, such as its functional nature (and why this is important to concurrency) and pattern matching. Next we discussed how to implement distribution and fault tolerance, and we took a look at OTP, the "application server" for Erlang. We concluded the conversation with a littel discussion about how Erlang was designed, it's current community as well as its future. Lees meer
-
Episode 88: The Singularity Research OS with Galen Hunt
2 maart 2008 · 47 min
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. Lees meer
-
Episode 87: Software Components
21 februari 2008 · 1 uur
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. Lees meer
-
Episode 86: Interview Dave Thomas
11 februari 2008 · 40 min
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. Lees meer
-
Episode 85: Web Services with Olaf Zimmermann
1 februari 2008 · 52 min
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. Lees meer
-
Episode 84: Dick Gabriel on Lisp
22 januari 2008 · 1 uur
In this Episode we're talking with Dick Gabriel on Lisp. We started by looking at artificial intelligence as the historic context of Lisp, the goals AI tried to reach, and how Lisp was supposed to help reach those. We then discussed the language itself, starting with the Data As Program / Program As Data concept that is a foundation for Lisp. Then we discussed adding a meta-circular interpreter, programming as language development, and the blurred boundary between language and frameworks (because everything uses the same syntax). We then talked about Lisp's type system and the importance of macros to extend the language. The next section concerned CLOS, the Common Lisp Object System and its important concepts: generic functions, multimethods, mixins, and method combination. We also briefly looked at the meta-object protocol but agreed this is a topic for a separate episode. After a discussion about the various dialects of Lisp and Scheme, we concluded the Lisp discussion by explaining why Lisp did not really catch on ("AI Winter") and Lisp's role in today's industry. We ended the episode with a couple of details about Dick's other life as a poet and his Poem a Day effort. Make sure you listen till the end, where we have added a song about Lisp (courtesy of Prometheus Music.) Lees meer
-
Episode 83: Jeff DeLuca on Feature Driven Development
12 januari 2008 · 40 min
In this episode we talk with Jeff DeLuca about Feature Driven Development (FDD). As one member of the agile methods family FDD is not so famous as Scrum or Extreme Programming but is becoming more and more popular, especially for situations where you have fixed price contracts. As the inventor of FDD Jeff gives short introduction to the method itself, talks about the basic ideas behind FDD and discusses with us how FDD relates to other members of the agile family. Lees meer
-
Episode 82: Organization of Large Code Bases with Juergen Hoeller
2 januari 2008 · 51 min
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. Lees meer
-
Episode 81: Interview Erich Gamma
23 december 2007 · 42 min
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. Lees meer
-
Episode 80: OSGi with Peter Kriens and BJ Hargrave
13 december 2007 · 45 min
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? Lees meer
-
Episode 79: Small Memory Software with Weir and Noble
3 december 2007 · 1 uur
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. Lees meer
-
Episode 78: Fault Tolerance with Bob Hanmer Pt. 2
23 november 2007 · 46 min
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. Lees meer
-
Episode 77: Fault Tolerance with Bob Hanmer Pt. 1
13 november 2007 · 46 min
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. Lees meer
-
Episode 76: Special Episode on the Patterns Journal
9 november 2007 · 16 min
In this special Episode we briefly discuss the upcoming Patterns Journal with the two editors, Ralph Johnson and James Noble.
-
Episode 75: The New Website
4 november 2007 · 8 min
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.
-
Episode 74: Enterprise Architecture II
3 november 2007 · 45 min
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. Lees meer
-
Episode 73: Real Time Systems with Bruce Powel Douglass
24 oktober 2007 · 1 uur
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. Lees meer
-
Episode 72: Erik Meijer on LINQ
17 oktober 2007 · 53 min
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.). Lees meer
-
Episode 71: Survey Results
13 oktober 2007 · 32 min
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.
-
Episode 70: Gerard Meszaros on XUnit Test Patterns
4 oktober 2007 · 53 min
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. Lees meer
-
Episode 69: Nico Josuttis on SOA (SOA Pt. 3)
25 september 2007 · 57 min
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. Lees meer
-
Episode 68: Dan Grossman on Garbage Collection and Transactional Memory
14 september 2007 · 54 min
This episode features a discussion with Dan Grossman about an essay paper he wrote for this year's OOPSLA conference. The paper is about an analogy between garbage collection and transactional memory. In addition to seeing the beauty of the analogy, the discussion also serves as a good introduction to transactional memory (which was mentioned in the Goetz/Holmes episode) and - to some extent - to garbage collection. Lees meer
-
Episode 67: Roundtable on MDSD and PLE
4 september 2007 · 49 min
This is a roundtable discussion on model-driven software develoment and product line engineering. It was recorded at the Model-Driven Development and Product Lines: Synergies and Experience conference in October 2006 in Leipzig. The panelists are: Lees meer
Axel Uhl, SAP
Danilo Beuche, Pure Systems
Juha Pekka Tolvanen, MetaCase
Tom Stahl, b+m
Ruediger Schilling, Delta Software Technology
-
Episode 66: Gary McGraw on Security
25 augustus 2007 · 41 min
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'. Lees meer
-
Episode 65: Introduction to Embedded Systems
15 augustus 2007 · 44 min
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. Lees meer
-
Episode 64: Luke Hohmann on Architecture and Business
5 augustus 2007 · 53 min
In this episode we talk about the relationship between software architecture and the business. Based on his book, Beyond Software Architecture we discuss how things such as branding, licensing, updating or different deployment scenarios influence the technical architecture of a system. We also discuss issues such as portability that add a huge amount of complexity, although from a business perspective it often does not make much sense. In the second part of the interview we discuss how the technical team and the business team can improve the way they work together. We look at some of the games (such as Buy a Feature or Give them a Hot Tub) from his new book Innovation Games, which discusses how to use collaborative play to be more creative and innovative in product creation. Lees meer
-
Episode 63: A Pattern Language for Distributed Systems with Henney and Buschmann
26 juli 2007 · 1 uur 7 min
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: Lees meer
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
-
Episode 62: Martin Odersky on Scala
16 juli 2007 · 54 min
In this Episode we talk about the Scala language with its creator Martin Odersky. Scala is a language that fuses object oriented and functional programming. Martin started out by providing a two-minute overview over the language, and then talked a little bit about its history. We then discussed the basics of functional programming. The main part of the episode features a discussion of some of the important features of the Scala language: Lees meer
Case Classes and Pattern Matching
Multiple Inheritance and Compound Types, Traits, Mixins
Closures
Functions as types, "Function pointers", Anonymous functions
Higher Order Functions
Currying
(Sequence) Comprehensions
Generics
Type Bounds (Upper, Lower)
Static/Dynamic Typing, Type Inference
Operators
Implicits
We then talked about Scala's actors library, a highly scalable concurrency package. The last part of the episode covered some more general topics, such as where and how Scala is used today, IDE support and the user and developer community. We concluded the episode by looking at current development and next steps in Scala language evolution.
-
Episode 61: Internals of GCC with Morgan Deters
6 juli 2007 · 53 min
This show takes a behind-the-scenes look at compilers and their inner workings, using the Gnu compiler collection (GCC) as an example. Arno interview Morgan Deters, covering all steps from the parsing of different programming languages to machine independenet optimizations and generating processor specific binary code. Lees meer
-
Episode 60: Roman Pichler on Scrum
26 juni 2007 · 1 uur 1 min
This episode features Scrum, a very popular Agile software development framework. We interview Roman Pichler, a Certified ScrumMaster Trainer and independent consultant. Roman explains the principles behind Scrum, its roles and its key practices. He also answers FAQs. This episode continues our track on software development processes discussing an additional Agile method. Roman is currently writing a book on Scrum in German that provides more in-depth information of the topics discussed in the podcast. The book will be available in autumn 2007 published by d.punkt (Heidelberg, Germany). Lees meer
-
Episode 59: Static Code Analysis
16 juni 2007 · 46 min
This episode is a discussion with Jonathan Aldrich (Assistant Professor at CMU) about static analysis. The discussion covered theory as well as practice and tools. We started with an explanation of what static analysis actually is, which kinds of errors it can find and how it is different from testing and reviews. The core challenge of such an analysis tool is to understand the semantics of the program and reduce its possible state space to make it analysable - in effect reconstructing the programmer's intent from the code. The user can "help" the tool with this challenge by using suitable annotations; also, languages could do a better job of being analysable. The conceptual discussion was concluded by looking at the principles of static analysis (termination, soundness. precision) and how this approach relates to model analysis. The second more practical part started out with a discussion of how Microsoft successfully uses static analysis in their Windows development. We then discussed some of the tools available; these include Findbugs, Coverity, Codesonar, Clockwork, Fortify, Polyspace and Codesurfer. To conclude the discussion of tools, we discussed the commonalities and differences with architecture visualization tools as well as metrics and heuristics. Part three of the discussion briefly looked at how to introduce static analysis tools into an organization's development process and tool chain. We concluded the discussion by looking at situations where static analysis does not work, as well as at the FLUID research project at CMU. Lees meer
-
Episode 58: Product Line Engineering Pt. 2
6 juni 2007 · 48 min
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. Lees meer
-
Episode 57: Compile-Time Metaprogramming with Laurence Tratt
27 mei 2007 · 45 min
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. Lees meer
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.
-
Episode 56: Sensor Networks with Steffan Schaefer
17 mei 2007 · 45 min
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. Lees meer
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.
-
Episode 55: Refactoring Pt. 2
7 mei 2007 · 32 min
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. Lees meer
-
Episode 54: Interview Frank Buschmann
27 april 2007 · 42 min
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. Lees meer
-
Episode 53: Product Line Engineering Pt. 1
17 april 2007 · 45 min
Michael Kircher and Markus Voelter introduce the topic of software product line engineering. They motivate when and why product lines are important to consider and what makes them so special. Further, they introduce some key terminology, such as platform, core asset, feature model, commonality, and variability. Lees meer
-
Episode 52: DSL Development in Ruby
7 april 2007 · 51 min
In this episode, we're talking to Obie Fernandez about agile DSL development in Ruby. We started our discussion by defining what a DSL is, the difference between internal and external DSLs as well as the importance of the flexibly syntax of the host language in order to make DSLs worthwhile. We then looked at a couple of real world examples for DSLs, specifically, at Business Natural Languages. We then progressed to the main part of the discussions, which centered around the features of Ruby that are important for building DSLs. These include the flexible handling of parentheses, symbols, blocks as well as literal arrays and hashes. We then discussed Ruby's meta programming feautures and how they are important for building DSLs: instantiation, method_missing callback, class macros, top level functions and sandboxing. Features like eval, class_eval, instance_eval and define_method are also important for DSLs in Ruby, as well as using alias_method for simple AOP. Lees meer
-
Episode 51: Design By Contract
28 maart 2007 · 37 min
In this episode, Arno and Michael take a look at Design by Contract, a programming technique formalized by Bertrand Meyer. The idea is that an interface is more than method signatures - it is also about specifying the expected behavior that implementations must provide. While some languages include direct support for this style of programming, it is a useful mindset when desiging interfaces even without such language features. Lees meer
-
Episode 50: Announcements and Requests
22 maart 2007 · 8 min
This is another episode where we mainly announce topics related to the podcast itself.