 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. 

OOPSLA 2007

Episode 24: Keynote -- Pattie Maes

 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. 

Episode 23: Keynote -- Gregor Kiczales

 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. 

Episode 22: Keynote -- David Lorge Parnas

 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. 

Episode 21: Keynote -- John McCarthy

 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. 

Episode 20: Keynote -- Frederick Brooks

 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! 

Episode 19: Keynote -- 50 in 50

 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. 

Episode 18: Keynote -- Second Life

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

Episode 17: Keynote -- Kathy Sierra

 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. 

Episode 16: Keynote -- Peter Turchi

 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. 

Episode 15: The Eclipse Technology Exchange

 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. 

Episode 13: Aggressive Learning

 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. 

Episode 12: Using FindBugs in Anger

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

Episode 11: Unit Testing Patterns

 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. 

Episode 10: Agile Software Development on a Global Scale

 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. 

hubhopper

OOPSLA 2007

hubhopper