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.

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.

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.

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.

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.

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!

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.

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

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.

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.

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.

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.

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 test frameworks, and how to keep your test suites as clean and valuable to you as your production code.

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.

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.

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.

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.

Host: Dan Steinberg

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.

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.

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.

Host: Daniel Steinberg

The Ruby programming language has taken the software world by storm, as scripting language, as development language, and as the host of the influential Rails web development framework. Programmers who come to Ruby are surprised by their productivity and freedom -- and by how much fun they have!

Becoming an accomplished user of Ruby takes a little practice. One way to jump-start the learning process is to study 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.

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, and in 2007, PLoP continues to provide an opportunity for pattern writers to improve their work and form communities with other software developers.

The patterns community has always had a close relationship with ooPSLA, culminating in the co-location of PLoP 2006 with ooPSLA in Portland. This year PLoP returns to Allerton Park, but ooPSLA again offers folks a touch of PLoP in the form of two workshops, a Pattern Writing Bootcamp and a Writers Workshops for Papers in Software Development.

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

Host: Markus Völter

Many programmers know that there are paths to increased productivity that are orthogonal to objects. Language designer Martin Odersky is in the vanguard that studies how to augment OOP with techniques from the world of functional programming. 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.

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.