OOPSLA 2007

By OOPSLA 2007Technology Tech News

OOPSLA 2007 episodes

October 01, 2007 Episode 13: Aggressive Learning
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.
0 min
September 24, 2007 Episode 12: Using FindBugs in Anger
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.
0 min
September 17, 2007 Episode 11: Unit Testing Patterns
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.
0 min
September 10, 2007 Episode 10: Agile Software Development on a Global Scale
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.
0 min
September 03, 2007 Episode 9: Garbage Collection and Transactional Memory
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.
0 min
August 27, 2007 Episode 8: Juha Pekka-Tolvanen on Domain-Specific Modeling
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.
0 min
August 20, 2007 Episode 7: Gary McGraw on Security
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.
0 min
August 13, 2007 Episode 6: Agility Unlimited
Guest: Jens Coldewey

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.
0 min
August 06, 2007 Episode 5: Software Architecture
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.
0 min
July 30, 2007 Episode 4: Ruby
Guest: Glenn Vanderburg

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

About OOPSLA 2007

From the publisher's feed

OOPSLA 2007 Conference Podcast

Share OOPSLA 2007

Sign up to save your podcasts

OOPSLA 2007

OOPSLA 2007 episodes

About OOPSLA 2007