In this episode we look at SUN's open source strategy for the OpenJDK. We discuss challenges in creating such a big open source project, and ways to keep it focused and organized. We discuss what it means for the Java runtime to be adopted as the technological foundation for other programming languages.

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.

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

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.

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 […]

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 […]

Recording Venue: Phone Guest: Jeff Frey System z, or the Mainframe, holds most of us in awe — the ultimate computing platform, referenced in Hollywood as well as by those who thought they were dealing with “legacy” systems — but what does Mainframe really mean? What does its stack look like? This leading virtualized infrastructure […]

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 […]

For Episode 200 of Software Engineering Radio, Diomidis Spinellis interviews Markus Völter, the podcast’s founder. Markus works as an independent researcher, consultant, and coach for itemis AG in Stuttgart, Germany. His focus is on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus also regularly publishes articles, […]

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; […]

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 […]

Gernot Starke talks about arc42: an open-source set of templates he developed to document software architecture based on his practical experience with real projects. Also Gernot and host Eberhard then discuss how documenting architecture fits into agile processes and how to find the right amount of documentation for a system. They walk through the different parts of the arc42 templates covering requirements and the context of the system and the solution structure, including building blocks, runtime, and deployment. They discuss tooling, versioning, testing documentation, and how to keep documentation up to date.

John Wilkes from Google talks with Charles Anderson about managing large clusters of machines. The discussion starts with Borg, Google’s internal cluster management program. John discusses what Borg does and what it provides to programmers and system administrators. He also describes Kubernetes, an open-source cluster management system recently developed by Google using lessons learned from Borg, Mesos, and Omega

Sven Johann talks with Andrew Phillips about DevOps. First, they try to define it. Then, they discuss its roots in agile operations, its relationship to lean development and continuous delivery, its goals, and how to get started. They proceed to system thinking and what “You build it, you run it” means for a system when developers have pager duty.

They continue with the diversity of DevOps requirements among companies and industries; copying ideas versus finding your own way; culture, mindset, and recommended practices; and the mandatory tool chain. They wrap up by discussing architectural styles that support DevOps and DevOps costs versus benefits.

Johannes Thönes talks to Axel Rauschmayer about JavaScript and ECMAScript 6. They talk about the origin and version history. Then they dive into key JavaScript concepts and explain the features coming into the language with ECMAScript 6.

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.

Charles Anderson talks with James Phillips about service discovery and Consul, an open-source service discovery tool. The discussion begins by defining what service discovery is, what data is stored in a service discovery tool, and some scenarios in which it’s used. Then they dive into some details about the components of a service discovery tool and how reliability is achieved as a distributed system. Finally, James discusses Consul, the functions it provides, and how to integrate it with existing applications, even if they use configuration files instead of a service discovery tool.

Eberhard Wolff talks with Jürgen Höller about Reactive Spring. Reactive programming is a hot topic, but adoption has been slow in the enterprise. Spring 5 incorporates Reactor and the RxJava API to help Java developers build scalable high-performance web applications. The discussion explores architectural challenges, transactions, porting existing applications, and increased code complexity.

Felienne talks with Sam Aaron on Sonic Pi about how he designed Sonic Pi, a language, both for professional musicians performing with code as well as for schoolchildren.

Björn Rabenstein discusses the field of Site Reliability Engineering (SRE) with host Robert Blumen. The term SRE has recently emerged to mean Google's approach to DevOps. The publication of Google's book on SRE has brought many of their practices into more public discussion. The interview covers: what is distinct about SRE versus devops; the SRE focus on development of operational software to minimize manual tasks; the emphasis on reliability; Dickerson's hierarchy of reliability; how reliability can be measured; is there such a thing as too much reliability?; can Google's approach to SRE be applied outside of Google?; Björn's experience in applying SRE to Soundcloud - what worked and what did not; how can engineers best apply SRE to their organizational situation?; the importance of monitoring; monitoring and alerting; being on call, responding to incidents; the importance of documentation for responding to problems; they wrap up with a discussion of why people from non-computer science backgrounds are often found in devops and SRE.

John Allspaw CTO of Etsy speaks with Robert Blumen about systemic failures and outages. Why they cannot be totally prevented, how to respond, and what we can learn from them.

Docker Security Team lead Diogo Mónica talks with SE Radio’s Kim Carter about Docker Security aspects. Simple Application Security, which hasn’t changed much over the past 15 years, is still considered the most effective way to improve security around Docker containers and infrastructure. The discussion explores characteristics such as Immutability, the copy-on-write filesystem, as well as orchestration principles that are baked into Docker Swarm, such as mutual TLS/PKI by default, secrets distribution, least privilege, content scanning, image signatures, and secure/trusted build pipelines. Diogo also shares his thoughts around the attack surface of the Linux kernel; networking, USB, and driver APIs; and the fact that application security remains more important to focus our attention on and get right.

Asaf Yigal talks with SE Radio’s Edaena Salinas about machine learning in log analysis. The discussion starts with an overview of the structure of logs and what information they can contain. Asaf discusses what the log analysis process looks like without machine learning -- and the role of humans in this – before moving on to how the process is improved by incorporating external resources using machine learning. Topics include: log analysis, machine learning, operations.

Felienne talks with Evgeny Shadchnev about Code Schools, programs that prepare people to become a software developer in a few months. This episode explores the idea of code schools. Can we really teach programming in a few months rather than in a few years in university? Who teaches at those programs? Who attends them? What are their business models and should we teach programming online or offline?

Scott Piper and Kim Carter discuss Cloud Security. The Shared Responsibility Model, assets, risks, and countermeasures, evaluation techniques for comparing the security stature of CSPs. Scott discusses his FLAWS CTF engine. Covering tools Security Monkey and StreamAlert.

What is code coverage, how can you measure it, and what are the pitfalls of this metric? Diomidis Spinellis talks with Marc Hoffmann, a key developer of the JaCoCo code coverage library for Java, on how code test coverage can improve software reliability

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.

Travis Kimmel talks with Lara Hogan and Deepa Subramaniam about evidence-based tactics that product and engineering leaders can use to can use to diagnose problems that are holding back their teams, and build healthier, high-performing organizations.

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

István Lam of Tresorit talks with host Kim Carter about GDPR (the EU General Data Protection Regulation, which has been described as “the most important change in data privacy regulation in 20 years.”)  The discussion covers terminology, planning, implementation, users' rights regarding their personal data, managing personally identifiable information (PII) across an organization, and required documentation. István talks about establishing the intent of different types of PII; when data can be shared or sold, when PII can be stored; storage of backups, and the ability to reveal, modify, or remove all of a customer's PII.

Kishore Bhatia discussed Ethereum and Smart Contracts with John Crain. Topics include: understanding the motivations for a decentralized computing model, Application architecture on Ethereum, development frameworks and tools. John’s experience developing and launching his own product Pixura on Ethereum mainnet, approaches,

Edaena Salinas talks with Pat Helland about Web Scale. Pat is a Principal Software Architect at Salesforce where he works on a cloud based multi-tenant database technology. The discussion covers: Datacenters and hardware, DevOps, developing at scale, stateless vs stateful services, preparing a system for failures and sql vs nosql databases.