Software Engineering Radio - the podcast for professional software developers cover image

Software Engineering Radio - the podcast for professional software developers

Latest episodes

undefined
Jan 22, 2008 • 1h

Episode 84: Dick Gabriel on Lisp

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.)
undefined
Jan 12, 2008 • 40min

Episode 83: Jeff DeLuca on Feature Driven Development

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.
undefined
Jan 2, 2008 • 51min

Episode 82: Organization of Large Code Bases with Juergen Hoeller

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.
undefined
Dec 23, 2007 • 42min

Episode 81: Interview Erich Gamma

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.
undefined
Dec 13, 2007 • 45min

Episode 80: OSGi with Peter Kriens and BJ Hargrave

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?
undefined
Dec 3, 2007 • 1h

Episode 79: Small Memory Software with Weir and Noble

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.
undefined
Nov 23, 2007 • 46min

Episode 78: Fault Tolerance with Bob Hanmer Pt. 2

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.
undefined
Nov 13, 2007 • 46min

Episode 77: Fault Tolerance with Bob Hanmer Pt. 1

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.
undefined
Nov 9, 2007 • 16min

Episode 76: Special Episode on the Patterns Journal

In this special Episode we briefly discuss the upcoming Patterns Journal with the two editors, Ralph Johnson and James Noble.
undefined
Nov 4, 2007 • 8min

Episode 75: The New Website

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.

Get the Snipd
podcast app

Unlock the knowledge in podcasts with the podcast player of the future.
App store bannerPlay store banner

AI-powered
podcast player

Listen to all your favourite podcasts with AI-powered features

Discover
highlights

Listen to the best highlights from the podcasts you love and dive into the full episode

Save any
moment

Hear something you like? Tap your headphones to save it with AI-generated key takeaways

Share
& Export

Send highlights to Twitter, WhatsApp or export them to Notion, Readwise & more

AI-powered
podcast player

Listen to all your favourite podcasts with AI-powered features

Discover
highlights

Listen to the best highlights from the podcasts you love and dive into the full episode