OOPSLA 2007 Podcast

Podcast

The ooPSLA podcast brings you up to speed on topics covered at this year's conference.

Episodes include coverage of notable tutorials, workshops, technical papers, essays, invited talks, and Onward! events.

The podcast is co-produced with Software Engineering Radio and DimSumThinking.

All podcast episodes are licensed under a Creative Commons 2.5 License.

Subscribe to this podcast

Episode 24: Keynote — Pattie Maes
published October 25, 2007

Speakers: Pattie Maes

The ooPSLA 2007 keynote series closed with Pattie Maes talking about Meta-Objects for the World Around Us. Her talk was a fitting bookend to Kiczales's address in the morning, as Maes described ongoing work at the MIT Media Lab to make available all of the information available to people when they need it as they live their lives — "users" using data and services in context.

Maes's topic also offered a fitting close to ooPSLA, which has always ultimately been about making the world a better place through programs, systems, languages, and applications.

download/play MP3 | help listening
(runtime: 0:47:02, 21.5 MB)

Episode 23: Keynote — Gregor Kiczales
published October 25, 2007

Speakers: Gregor Kiczales

The third and final day of ooPSLA 2007 began with Gregor Kiczales speaking about a theme that has underlay his work throughout the years, from the metaobject protocol and objects to aspect-oriented programming: the role played by context in how people see software when they come to it as developer, user, maintainer, and extender. His keynote address was titled Context, Perspective and Programs.

download/play MP3 | help listening
(runtime: 1:14:40, 34.2 MB)

Episode 22: Keynote — David Lorge Parnas
published October 24, 2007

Speakers: David Lorge Parnas

A day of pioneers speaking at ooPSLA 2007 ended with another seminal thinker in software engineering, David Parnas, talking about Precise Software Documentation: Making Object Orientation Work Better. In keeping with one of the longstanding themes of his work, Parnas argues that for a true separation of concerns, one that extends to documents we create for programmers and for people who will never read our code.

download/play MP3 | help listening
(runtime: 1:39:57, 45.8 MB)

Episode 21: Keynote — John McCarthy
published October 24, 2007

Speakers: John McCarthy

The ooPSLA 2007 keynote series continued with John McCarthy, the creator of Lisp and a pioneer of so many fundamental ideas in programming languages. He spoke on one of his recent language projects, Elephant 2000: A Programming Language Based on Speech Acts.

download/play MP3 | help listening
(runtime: 1:14:35, 34.1 MB)

Episode 20: Keynote — Frederick Brooks
published October 24, 2007

Speaker: Frederick Brooks

The second day of ooPSLA 2007 opened with a keynote by computing pioneer Frederick Brooks, the author of the classic The Mythical Man-Month. His talk is on Collaboration and Telecollaboration in Design.

download/play MP3 | help listening
(runtime: 1:22:07, 37.6 MB)

Episode 19: Keynote — 50 in 50
published October 23, 2007

Speakers: Guy Steele & Richard Gabriel

The first day of ooPSLA 2007 ended with treat, Guy Steele & Richard Gabriel talking about the lessons we can learn from Programming Languages past in 50 in 50.

If you've ever attended a talk by either Steele or Gabriel at an ooPSLA, then you know that their "talks" are so much more. This is the one ooPSLA keynote that probably loses some of its impact as a podcast, but we think you'll want to hear it for its content!

download/play MP3 | help listening
(runtime: 1:26:25, 39.6 MB)

Episode 18: Keynote — Second Life
published October 23, 2007

Speakers: Jim Purbrick & Mark Lentczner

The third ooPSLA 2007 keynote of the opening day is by Jim Purbrick & Mark Lentczner, the creators of the increasingly influential Second Life. Their talk is titled Second Life: The World's Biggest Programming Environment.

download/play MP3 | help listening
(runtime: 1:28:32, 40.5 MB)

Episode 17: Keynote — Kathy Sierra
published October 23, 2007

Speaker: Kathy Sierra

The second ooPSLA 2007 keynote features author, teacher, and A-list blogger Kathy Sierra, on Creating Passionate Users.

download/play MP3 | help listening
(runtime: 1:22:23, 37.7 MB)

Episode 16: Keynote — Peter Turchi
published October 23, 2007

Speaker: Peter Turchi

For the first time, ooPSLA is podcasting its keynote talks. Watch this page for the full line-up!

Opening the conference is acclaimed poet Peter Turchi, with Once Upon a Time, Like Never Before: The Challenge of Telling the Next Story.

download/play MP3 | help listening
(runtime: 1:24:55, 38.9 MB)

Episode 15: The Eclipse Technology Exchange
published October 15, 2007

Guest: Cheryl Morris, Alex Orso, Li-Te Chang, Martin Robillard
Host: Martin Lippert

Over the last few years, Eclipse has grown from a simple little IDE into a platform for developing software that can be used at many levels of complexity.

At OOPSLA 2002, IBM announced the first round of Eclipse Innovation Grants, which funded 49 academics and researchers to do explore the uses of Eclipse in their work. These projects expanded the base of the software platform, but it also created something just as valuable: personal experiences growing and using Eclipse for teaching and research.

Then, at OOPSLA 2003, the grant recipients presented their results in the first Eclipse Technology Exchange (ETX) workshop. This year, the organizers return to ooPSLA for the fifth workshop in the series. It will be held on Sunday, October 21, the first day of workshops and tutorials.

This year's workshop will focus on the use Eclipse as a platform in teaching and research. It provides academics and researchers an opportunity to share their results and to help others to build on these experiences.

In addition to experience reports, the fifth ETX offers an opening keynote address by Jeff McAffer, IBM Rational, titled "Equinox -- Trends in Eclipse as a Runtime". Jeff leads the Eclipse Equinox OSGi team in "forging new ground for Eclipse as a runtime", seeking to do for the server what Eclipse has already done to client-side tool development.

In this podcast, Martin Lippert of Software Engineering Radio chats with the organizers of the 2007 ETX organizers at ooPSLA -- Cheryl Morris (IBM Toronto), Alex Orso (Georgia Tech), Li-Te Chang (IBM Cambridge), and Martin Robillard (McGill University) -- to talk first about the history of the ETX workshops and poster sessions and then about some of the exciting elements of this year's workshop program.

download/play MP3 | help listening
(runtime: 19:51, 9.1 MB)

Episode 13: Aggressive Learning
published October 1, 2007

Guest: Ted Neward
Host: Daniel Steinberg

Anyone who develops software for a living, or who works for an organization that does, knows the challenge of keeping up with changes in technology. Tools change. Methodologies change. Frameworks change. Languages change. For us, change is a central fact of life.

Even when a software developer is not being driven by change, she faces a daunting task. The world of computer science is big, as is the world of software development. No matter how much we know, there is more to know. So you've mastered OOP -- what about functional programming or logic programming? You are a Java or Smalltalk guru, but what about Scheme or Erlang?

The more tools we have in our toolbox, the better prepared we are for our next task. The more kinds of things we know, the better we can use use the tools in our toolbox.

Ted Neward is a software developer facing these challenges head-on. He has been aggressively learning several new languages of late, expanding his repertoire. Later this month, he'll be at ooPSLA, too.

Anyone who has ever attended ooPSLA knows that it is the best conference around for adding tools to your toolbox and new ideas to your thinking. This year is no exception.

Neward himself is contributing to the mix od new ideas at ooPSLA with two tutorials: one with Erik Meijer on LINQ, and one with Martin Odersky and Gilles Dubochet on Scala. Each of these tutorials teaches new tools, as well as new ways of thinking.

Listen to this podcast to hear Daniel Steinberg of DimSum Thinking talk with Neward about aggressively learning new ideas, about adding tools to your tool box, and about why he likes Scala so much.

download/play MP3 | help listening
(runtime: 21:28, 9.8 MB)

Episode 12: Using FindBugs in Anger
published September 24, 2007

Guest: Bill Pugh
Host: Daniel Steinberg

Bill Pugh, a computer science professor at the University of Maryland, is on a quest. As an academic, it is sometimes too easy to lose touch with the issues that face software developers in the trenches. He doesn't want to fall victim to this risk. Then again, folks who know Pugh's work would never suggest that he has.

Pugh is the author of a program called FindBugs, a static analysis tool for detecting errors in Java programs. It has famously found several interesting bugs in the JDK standard libraries. This past, summer, Pugh worked at Google to help integrate FindBugs into its development environment and improve its code base.

FindBugs is a great example of "accidental research"... Work on techniques for compressing Java class files produced utilities for doing static analysis of source code, which ultimately found a new application in detecting standard classes of errors that we programmers make in our code.

You don't have to be Google to benefit from FindBugs or Pugh's expertise. Along with his colleague David Hovemeyer, he will teach a tutorial at ooPSLA titled Using FindBugs in Anger. In this tutorial, you'll learn how to incorporate FindBugs into your software development process, with an emphasis on solving issues that arise on projects with large code bases and multiple developers. Topics include differential analysis, for studying changes in the code base since the last build or release; persistent auditing; and annotations.

In this podcast, Pugh joins Daniel Steinberg of DimSumThinking to chat about static analysis tools, his own FindBugs tool for Java, and how to use such tools most effectively in improving the quality of your code base.

download/play MP3 | help listening
(runtime: 21:48, 10.0 MB)

Episode 11: Unit Testing Patterns
published September 17, 2007

Guest: Gerard Meszaros
Host: Martin Lippert

Perhaps the greatest contribution of the agile methods community to software development has been the practice of automated unit testing: the writing of tests by programs that help to specify, document, and verify the code in our systems. Automated unit tests make possible other practices, such as refactoring and collective code ownership, and they help us to ensure a high-level of qaulity in our product.

Tests are great, but we must keep in mind that they are code, too. The test suite grows over time, and without care we can run into the same sort of problems with our tests that we encounter in our code. Unlike production code, however, our tests sometimes feel optional, in that the team might think it can stop writing and maintaining tests when the perceived costs begin to exceed the perceived benefits.

Gerard Meszaros, a developer and consultant with 25 years experience in software and a nearly a decade of experience in agile methods, wants to help teams avoid this calamity. He has documented his understanding of unit test suites in a comprehensive set of patterns for writing, monitoring, and maintaining test code.

In this regard, Meszaros will teach an ooPSLA tutorial, titled Unit Test Patterns and Smells: Improving Test Code and Testability Through Refactoring. This tutorial, presented as a case study, teaches the best practices -- and "not so best practices" -- of unit testing as a set of patterns and as a set of smells for recognizing when the suite is going astray.

Listen to this podcast to hear Martin Lippert of SE Radio talk with Gerard about unit testing, the Nunit family of automated testing frameworks, and how to keep your test suites as clean and valuable to you as your production code.

download/play MP3 | help listening
(runtime: 33:49, 14.6 MB)

Episode 10: Agile Software Development on a Global Scale
published September 10, 2007

Guest: Jutta Eckstein
Host: Daniel Steinberg

Agile software development methods grew up in a context of in-house development, collocated teams, and relatively shared cultural expectations. This made their emphasis on face-to-face communication and common code ownership.

But these days, software development is as likely to be developed by international teams as it is by teams sitting in the same room. Terms such as "outsourcing", "offshoring", and "nearshoring" indicate the degree to which agile software developers must work in a context rather different from the one in which their methods have been honed.

Over the last decade, Jutta Eckstein, of IT Communication in Germany, has developed a wealth of experience developing object-oriented applications in large organizations, precisely the ones most likely to develop software with distributed, international teams. She has identified ways in which it is possible for such teams to overcome the challenges that global software development, as well as the success factors for implementing an agile software development process within such constraints.

Eckstein will teach a tutorial at ooPSLA, titled Agile in Face of Global Software Development, that shares this experience with conference attendees.

In this podcast, Eckstein joins Daniel Steinberg of DimSumThinking to talk about how agile software development in the face of trends toward global teams. She offers concrete suggestions for overcoming problems of distance, culture, and time zone in implementing agile approaches.

download/play MP3 | help listening
(runtime: 21:35, 9.9 MB)

Episode 9: Garbage Collection and Transactional Memory
published September 3, 2007

Guest: Dan Grossman
Host: Markus Völter

Programming languages researcher Dan Grossman from the University of Washington works on making programs safe in the context of shared memory and multi-core processors. Such research operates both at the language level and at the level of the hardware, which gives researchers such as Grossman a wide perspective on the techniques we use in building safe, reliable software systems.

At ooPSLA, Grossman will deliver an essay titled The Transactional Memory / Garbage Collection Analogy, which offers an intriguing analogy: transactional memory is to shared memory concurrency as garbage collection is to memory management. An essay is a different sort of paper that ooPSLA offers. Grossman won't break new technical ground in his talk; instead he will offer a new perspective on topics that we all deal with and explore the implications of thinking in this new way.

Listen to this podcast to hear Markus Völter of SE Radio chat with Dan about shared memory concurrency, memory management, and how thinking about the relationship between them can enrich our understanding of both -- and how this can improve the way we build software.

download/play MP3 | help listening
(runtime: 24:46, 11.3 MB)

Episode 8: Domain-Specific Modeling
published August 27, 2007

Guest: Juha Pekka-Tolvanen
Host: Daniel Steinberg

Every application domain has its own language. It has vocabulary, rules, and constraints. Historically, we have written software by implementing these vocabulary terms, rules, and constraints in a "high-level language" such as C++ or Java, or using a modeling language such as UML.

What gets Juha Pekka-Tolvanen of MetaCase out of bed every morning is a desire to improve in a fundamental way the productivity of software developers. He draws inspiration from studies that show it possible to achieve 500% to 1000% improvements -- not just in the speed of development, but also in the quality of the software produced.

At ooPSLA, Pekka-Tolvanen will lead the The 7th OOPSLA Workshop on Domain-Specific Modeling, along with Jeffrey Gray (University of Alabama at Birmingham), Matti Rossi (Helsinki School of Economics), and Jonathan Sprinkle (University of California, Berkeley).

This workshop will share community experience using domain-specific modeling for software development. Among the topics of the workshop are experience reports from industry and academia, the creation of metamodel-based languages, novel approaches for code generation from domain-specific models, issues in supporting and maintaining systems built with DSMs, and tool support. Papers range from typical information technology domains to hard-core scientific areas such as nuclear physics and the simulation of chemical processes.

In this podcast, Juha joins Daniel Steinberg of DimSumThinking to talk about the process and benefits of creating domain-specific models, the results of last year's workshop, and what is in store for this year's workshop.

download/play MP3 | help listening
(runtime: 17:11, 7.9 MB)

Episode 7: Gary McGraw on Security
published August 20, 2007

Guest: Gary McGraw
Host: Michael Kircher

Software security is an issue that everyone faces but that not everyone gets right. Sometimes, our languages programming claim to provide us a level of security that they cannot deliver.

Fortunately, folks like Gary McGraw, the CTO of Cigital, have studied software, language technology, and security. McGraw defines software security as "how to approach computer security if you are a software developer or architect". In his experience, the best way to build secure software is to have the people who build our systems think carefully about security while they are building them. Security is part of both the system's architecture and its implementation.

At ooPSLA, McGraw -- a globally-recognized authority on software security and the author of six best selling books on this topic -- is teaching a tutorial called Software Security: Building Security In that will present a detailed approach to getting past theory and putting software security into practice. The tutorial will give a lesson in applied risk management and then present a number of software security best practices.

Listen to this podcast to hear Michael Kircher of SE Radio chat with Gary about software security, patterns of attack on software, and some of the most timely issues in security as applied to on-line games.

download/play MP3 | help listening
(runtime: 22:37, 10.4 MB)

Episode 6: Agile Unlimited
published August 13, 2007

Guest: Jens Coldewey
Host: Dan Steinberg

Agile software development has been around for a while. Through experimentation and practice, we now know how to develop software in a way that values people over process and working code over talk. In many domains and contexts, agile development is an accepted way to build software. How can we adapt agile methods to contexts in which they've not traditionally been used? Can we do that and succeed?

Developers in some contexts face different challenges. On some projects, teams are widely distributed across the globe. In others, developers work on embedded systems or other systems with high reliability demands, in which detailed up-front specification are the norm. In these contexts, agile methods can be harder to apply, because we have less experience applying them there.

But they can work. People are trying and succeeding.

At ooPSLA, noted patterns and agile methods expert Jens Coldewey is leading a workshop called Agile Unlimited? that will gather folks to discuss their experiences applying agile methods beyond the traditional boundaries. Participants will discuss the key issues, share patterns of success, and raise unanswered questions. How flexible must one be with methodology? What elements of agility must one retain in order to succeed? What new practices help?

In this podcast, Jens joins Daniel Steinberg of DimSumThinking to talk about agile development and its application outside the traditional walls that industry -- and we ourselves -- sometimes erect around it.

download/play MP3 | help listening
(runtime: 14:33, 6.7 MB)

Episode 5: Software Architecture
published August 6, 2007

Guest: Michael Stal
Host: Bernd Kolb

Every system has an architecture -- even if you just start writing code. As systems grow in size, importance, and responsibility, though, Siemens' Michael Stal believes that a systematic approach to defining and nurturing the shape of a system is the only way to ensure that the system meets all of its requirements. These include not just the explicit requirements understood by the client and developer, but also the implicit requirements that often go undocumented.

At ooPSLA, Michael is offering a pair of tutorials aimed at helping us all understand how to design and implement high-quality systems. His tutorials are titled High Quality Software Architecture and Software Architecture Refactoring. Yes: you can refactor your software architecture as part of improving the performance of your system. Michael will show you how.

Listen to this podcast to hear Bernd Kolb of SE Radio chat with Michael about software requirements, software architecture, and how to lay the foundation of high quality software.

download/play MP3 | help listening
(runtime: 25:04, 11.5 MB)

Episode 4: Ruby
published July 30, 2007

Guest: Glenn Vanderburg
Host: Daniel Steinberg

The Ruby programming language has taken the software world by storm, first as a scripting language that puts objects at the developer's fingertips, and then via the influential and increasingly popular Rails web development framework.

Programmers who come from statically-typed languages to Ruby are astounded at their newfound productive. Programmers who come from other dynamically-typed languages are pleasantly surprised to find their favorite features in Ruby, designed well and easy to use.

Becoming an accomplished user of Ruby takes a little practice, as the programmer encounters the many features available and learns to use the new idioms it provides. One way to jump-start the learning process is to study a bit with a master. To this end, ooPSLA is offering a tutorial called "An Introduction to Ruby" by accomplished Rubyist and teacher Glenn Vanderburg.

In this podcast, Glenn joins Daniel Steinberg of DimSumThinking to talk about Ruby, some of the advantages of making Ruby your "go to" language, and some of the ways that Ruby will expand how you think about programming and programming languages.

download/play MP3 | help listening
(runtime: 19:18, 9.2 MB)

Episode 3: MiniPLoP at OOPSLA
published July 23, 2007

Guests: Linda Rising, Joe Yoder, and Bob Hanmer
Host: Daniel Steinberg

When the seminal book Design Patterns made its public debut at ooPSLA 1994, the world of software developers changed forever. Soon everyone wanted to learn patterns and, even better, write patterns -- to document their knowledge of what software to build, and how.

That same year, a new sort of conference debuted as well, Pattern Languages of Programs, with the express purpose of helping pattern authors improve their work through writers' workshops. It is now 2007, and PLoP continues to provide this opportunity for pattern writers, as does its spin-off conferences in Europe, Scandinavia, and elsewhere.

The patterns community has always had a close relationship with ooPSLA, for historical reasons and because many of the more forward-thinking folks in software development find themselves working at ooPSLA. Last year, this relationship took a new form when PLoP 2006 co-located with ooPSLA in Portland.

While PLoP 2007 returns to Allerton Park, this year's ooPSLA again offers folks a touch of PLoP. ooPSLA and PLoP stand-outs Linda Rising, Bob Hanmer, and Joe Yoder have organized two workshops that collectively make up Mini-PLoP:

a Pattern Writing Bootcamp for those who are new to patterns and the software patterns community, and
a Writers Workshops for Papers in Software Development, for authors and non-authors to workshop current works in progress.

Listen to this podcast to hear Daniel Steinberg of DimSumThinking chat with Linda, Bob, and Joe about patterns, pattern writing, and the excitement of Mini-PLoP at ooPSLA.

download/play MP3 | help listening
(runtime: 20:56, 10.0 MB)

Episode 2: The Scala Experience
published July 16, 2007

Guest: Martin Odersky
Host: Markus Völter

ooPSLA regulars know that the conference isn't about only objects. Many programmers know that there are paths to increased productivity that are orthogonal to objects. If objects are not a silver bullet, where do OO programmers turn?

Language designer Martin Odersky is in the vanguard that studies how to augment OOP with techniques from the world of functional programming. These techniques offer ways in which OO programmers can program even more powerfully. Among Martin's earlier work, the Pizza and GJ extensions of Java influenced the development of Java 1.5.

His most recent work is on Scala, a programming language that "tries to achieve a fusion of object-oriented and functional programming, while remaining compatible with mainstream platforms such as Java and .NET. Scala is a new general-purpose programming language that is fully interoperable with Java, offers strong, static typing, and yet allows a terseness of style comparable to scripting languages.

At ooPSLA, Martin is offering a tutorial with colleagues Ted Neward and Gilles Dubochet titled The Scala Experience: Programming with Functional Objects. This tutorial will give an introduction to Scala, highlighting its main innovative features: closures, pattern matching, type abstraction, and mixins.

In this podcast, Martin joins Markus Völter of SE Radio to talk about what it's like to program in Scala.

download/play MP3 | help listening
(runtime: 26:46, 19.2 MB)

Episode 1: No Silver Bullet
published July 5, 2007

Guests: Dennis Mancl, Steven Fraser, and Bill Opdyke
Host: Markus Völter

Objects were not the silver bullet to solve all of our problems building software. Why not? Are there silver bullets on the horizon?

ooPSLA regulars Dennis Mancl, Steven Fraser, and Bill Opdyke have been thinking about these and many related questions for a number of years. They have also been working in industry to come up with better answers.

At ooPSLA 2007, Dennis, Steven, and Bill are leading a workshop titled No Silver Bullet: A Retrospective on the Essence and Accidents of Software Engineering in which participants will explore what we have learned about complexity in building software.

In this podcast, they join Markus Völter of SE Radio to discuss silver bullets and software development.

download/play MP3 | help listening
(runtime: 23:38, 16.2 MB)

Help Listening to the Podcasts

You can listen in one of two ways:

Play in Browser. If your web browser has been configured to play audio content, you may be able to click or left-click on the download/play link above and have your browser play the MP3 file directly.

Download to Computer. You may download the audio file directly to your hard drive for listening in your audio player of choice. Right-click (Windows) or control-click (Mac) on the download/play link above.