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.

In this episode Michael interviews one of our regular listeners: Petri Ahonen. Petri introduces Software Configuration Management by defining key terms and describing relevant concepts.

In this episode, Dirk talks with David Frankel, resident Metamodeller and MDA expert at SAP Labs LLC, SAP's subsidiary in the Silicon Valley. Dave's extensive experience provides a big picture, from the early days of CORBA all the way to current issues that are bugging most enterprise architects' work with MDA.

In this episode, Arno talks to Jim Melton about the SQL programming language. In addition to covering the concepts and ideas behind SQL, Jim shares stories and insights based on his many years' experience as SQL specification lead.

In this episode, Allan shares his insights about how learning is a necessary part of software development. He covers the personal as well as the team and the organizational level and offers practical advice.

This episode is once again with Linda Rising, this time on the book she coauthored with Mary Lynn Manns on introducing ideas into organizations. The talk is another one of the SE Radio Live sessions recorded at OOP 2009 - thanks to SIGS Datacom and programme chair Frances Paulisch for making this possible.

This episode is a conversation with Gilad Bracha about Newspeak, type systems in general and optional/pluggable types in particular. It was recorded during DSL Devcon in the gardens of the Microsoft campus, and thanks to Gilad's "speaking like a book" way of talking it is published completely unedited :-)

In the first part of this episode we discuss a couple of basics about SecondLife (scaling, partitioning, etc). The second part specifically looks at how the dev team tackled a number of interesting problems in the context of executing their own LSL scripting language on top of Mono.

This is another episode recorded at OOP 2009, thanks to SIGS Datacom and programme chair Frances Paulisch for making this possible. Here is the abstract from the conference program: Many software systems have fragile architectures that are based on brittle assumptions or rigid architectures that reduce options and make change difficult. On the one hand, an architecture needs to be fit for the present day, suitable for immediate use, and on the other it needs to accommodate the future, absorbing reasonable uncertainty. However, an approach that is overly focused on today's needs and nothing more can create an inflexible architecture. An approach that becomes obsessed with possible future changes creates an overly complex architecture that is unfit for both today's and tomorrow's needs. Both approaches encourage an early descent into legacy for a system. The considerations presented in this talk reflect an approach that is more about thinking in the continuous present tense than just the present or the future tense. This includes principles from lean thinking, practices common in agile processes and techniques for loosely coupled design.

This episode is a discussion with Jim Des Rivieres about APIs: How to design good APIs, the role of the documentation/specification in APIs, API evolution and other relevant topics.

In this episode we talk with Doug Simon from Sun Microsystems Laboratories about the Maxine Research VM, a so-called meta-circular virtual machine. Maxine is a JVM that is written itself in Java, but aims at taking JVM development to the next level while using highly integrated Java IDEs as development environments and running and debugging the VM itself directly from the Inspector, an IDE-like tool specialized for the Maxine VM. During the episode we talk about the basic ideas behind Maxine, what exactly "meta-circular" means and what makes it interesting and promising to build a Java VM in Java. We talk about the relationship to Sun's current production JVM (HotSpot) and about ideas and directions for the future of Maxine.

In this episode we discuss the current state of the spring framework. We talk about core features (dependency injection, AOP) but also about the spring universe, i.e. some of the more specific frameworks such as Spring Batch.

This episode is a discussion with various authors of patterns reviewed at EuroPLoP 2009. Topics include Product Line Engineering, Distributed Development, Open Source and Embedded Systems

Michael and Markus discuss what makes a good R&D manager and how to potentially become an R&D manager. You will learn what some of the essential skills are, what the challenges are, and what the 'mission/vision/strategy thing' is actually good for.

Dave explains why reading source code is at least as important a skill as writing source code. He shares approaches for how to get to grips with unknown and undocumented source code even if it is non-trivial in size. He finishes with advice for how to get started reading code.

Michael discusses with his guest Chuck Connell the differences between software engineering and computer science. What makes software engineering so unpredictable, with so few formal results? And how can we advance the field of software engineering without these results?

This episode is a conversation with "Uncle Bob" Bob Martin about agile software development and software craftsmanship specifically. We talk about the history of the term, the reasons for coming up with it some of the practices and the relationship to other agile approaches. We conclude our discussion with an outlook on some of todays new and hyped programming languages.

This episode is a discussion with Shane Clifford, who is a development manager at Intentional Software. We discuss the idea behind intentional programming, key concepts of the technology as well as example uses and a little bit of history.

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.

This episode is a conversation with Jan Bosch about product line engineering (PLE). Jan has worked in various roles and industries and academia in the context of product lines. In this episode we look at Jan's view of what is next for product lines: software ecosystems. What is their relationship to PLE and how should PLE change to remain relevant?

This is a conversation with Ola Bini on his experimental language Ioke. We cover the idea behind the Ioke experiment as well as important language concepts and the thinking behind them.

In this episode Johannes Link interviews Lasse Koskela - the author of "Test-Driven" - about test-driven development (TDD). We cover the basics, the rationale behind it and the challenges you face when doing it in more difficult environments.

This episode is part of our series on agile software development. We talk with David Anderson about Kanban, an agile software development method that is quite different from most of the other agile methods out there. We discuss the basic ideas behind Kanban, the differences between Kanban and Scrum and when and why projects can benefit from using Kanban. This episode is done in cooperation with the German magazine ObjektSpektrum (thanks for sharing this interview with us).

Philip Zeyliger of Cloudera discusses the Hadoop project with Robert Blumen. The conversation covers the emergence of large data problems, the Hadoop file system, map-reduce, and a look under the hood at how it all works. The listener will also learn where and how Hadoop is being used to process large data sets.

This episode is a coversation with Rich Hickey about his programming language Clojure. Clojure is a Lisp dialect that runs on top of the JVM that comes with - among other things - persistent data structures and transactional memory, both very useful for writing concurrent applications.

This episode is a conversation with Scott Meyers about the upcoming C++0x standard. We talk a bit about the reasons for creating this new standard and then cover the most important new features, including upport for concurrency, implicitly-typed variables, move semantics, variadic templates, lambda functions, and uniform initialization syntax. We also looked at some new features in the standard library.

This episode is a conversation with Ramnivas Laddad about aspect-oriented programming (AOP), Aspect J, and Spring AOP. We review the fundamental concepts of AOP, discuss AspectJ (an open source compiler that extends java with support for AOP), and cover the Spring Framework's proxy-based AOP system. Laddad also gives his thoughts on the use cases for AOP and where we are in the technology adoption curve, and updates on the state of the AspectJ project itself.

In this episode, we discuss with Roman Pichler how Scrum impacts product management and how agile product management differs from traditional approaches. The topics covered include product owners on large projects and product owner teams, facilitating customer feedback through early and frequent releases, envisioning the product, and creating products with the minimum functionality. Enjoy!

Jay Kreps talks about the open source data store Project Voldemort. Voldemort is a distributed key-value store used by LinkedIn and other high-traffic web sites to overcome the inherent scalability limitations of a relational database. The conversation delves into the workings of a Voldemort cluster, the type of consistency guarantees that can be made in a distributed database, and the tradeoff between client and the server.

Announcement regarding the release cycle.

This episode covers the topic of agile testing. Michael interviews Lisa Crispin as an practionier and book author on agile testing. We cover several topics ranging from the role of the tester in agile teams, over test automation strategy and regression testing, to continuous integration.

Dwight Merriman talks with Robert about the emerging NoSQL movement, the three types of non-relational data stores, Brewer's CAP theorem, the weaker consistency guarantees that can be made in a distributed database, document-oriented data stores, the data storage needs of modern web applications, and the open source MongoDB.

This time we have John Wiegand on the mic for an episode on architectures and agile software development. We talk about the role of architectures in an agile world and why architectures change and need to change over time. We discuss the characteristics of those living architectures, using the Eclipse and the Jazz projects as examples, and the surrounding development methods for such environments.

In this episode we talk with Kent Beck about automated unit testing and JUnit.

This episode is about being a consultant in the software business.

In this episode, Robert talks with Nati Shalom about the emergence of large-system architectures consisting of a grid of high-memory nodes.

In this episode Michael talks with Bas Vodde about how to apply agile principles to large and distributed development organizations.

This episode is an update on the developments around the Scala language.

Sven Apel explains why developing software in a feature-oriented manner is so vital for us as software engineers and why objects are simply not enough.

Recording Venue: University of Passau Guest: Sven Apel Host: Stefan In this second episode on Feature-Oriented Software Development (FOSD), Sven Apel gives us an overview of programming language and tool support for FOSD. He introduces the Eclipse-based FeatureIDE which covers important phases of the FOSD process, namely domain implementation as well as configuration and generation. […]

Guest: Wilbert Albers Host: Markus In this episode we take a look at microchip production, with a special focus on waferscanners. To do this, we talked with Wilbert Albers of ASML, the leading waferscanner manufacturer in the world. In the episode, we talk about the overall chip production process (from silicon sand over wafer cutting […]

We discuss characteristics and performance properties of modern games and outline the challenges for software development.

We talk with Martin Laforest about topics ranging from how quantum computing works, which different models of quantum computing are explored, current and future uses of the approach as well as the current state of the art.

Recording Venue: Phone Guest: Steve Will IBM i (formerly known as OS/400) is an advanced object-based operating system by IBM that runs thousands of businesses around the world.  Steve Will, the Chief Architect of IBM i speaks with us about the history, technical features, and underlying architecture discussing the concepts of Single Level Store, integrated […]

This episode is a conversation with Jonas Boner about Akka.

Cassandra is a distributed, scalable non-relational data store influenced by the Google BigTable project and many of the distributed systems techniques pioneered by the Amazon Dynamo paper.

In this episode Michael interviews Jurgen Appelo on the topic of leading agile developers.

In this episode we talk with Rini van Solingen about scrum and agile software development in distributed settings.

In this episode, Markus talk with Martin Fowler and Rebecca Parsons about domain-specific languages.

SE Radio will continue producing podcasts under the wings of IEEE Software, a respected magazine published by the IEEE Computer Society.