Glenn Vanderburg

: Speaking

For many years, I've enjoyed speaking in front of groups of people. I speak primarily on software development, in many different venues and on a variety of topics. I've spoken at JavaOne, SD West, O'Reilly Open Source Convention, and in many cities with the No Fluff, Just Stuff symposium tour. I've also spoken for local chapters of the IEEE Computer Society, as well as corporate groups.

My speaking schedule for the first half of 2005 includes Milwaukee, St. Louis, Denver, Reston, Raleigh, and Orlando.

Current talks include:

Talk Abstracts

JavaScript Exposed: There's a Real Programming Language In There!

JavaScript got a bum rap. It's almost universally derided among serious programmers for being a toy language, or for its strange characteristics, or bugs, or slowness, or because it's only good for adding useless window dressing to web pages.

For the most part, though, that stuff isn't inherent to JavaScript, and some of it is simply false. JavaScript is actually a very nice little language which is popping up everywhere: the Cocoon web framework, several Apple technologies (including Sherlock and Dashboard), Konfabulator, and other places. And of course, ActionScript, the programming language of Macromedia Flash, is really just a slightly modified version of JavaScript. Sure, JavaScript is quirky, but its problems are mostly due to history, association, and misunderstanding. Early implementations of JavaScript were buggy and slow, but those days are nearly gone. As a key weapon in the browser wars, JavaScript suffered due to incompatible browsers and DOM implementations, but many of those incompatibilities have gone away (and those that haven't can usually be hidden by one of the available cross-browser compatibility libraries).

An especially persistent problem, though, is misunderstanding. Let's face it: most developers learned JavaScript by looking at examples in web pages they found online, and few of those examples are paragons of JavaScript style. Other developers learned JavaScript from books, but the typical JavaScript book ignores the fundamentals of the language, instead focusing on examples and the fastest ways to do fancy web page tricks.

In this talk, we'll go back to the basics that most JavaScript resources omit. We'll talk about JavaScript as a language, learning its fundamental concepts and the simple rules that underlie the sometimes bewildering behavior. We'll learn about JavaScript's unusual object model, how to use it to build conventional object-oriented systems, and also how to exploit it more completely to do things you'd never think of doing in Java. We'll also learn some good ways to structure large JavaScript programs.

This talk is not about fancy web pages. It's about a powerful tool that can be used for fancy web pages, but that's also cropping up in many other places. It's worth your time to learn it well.

Java Collections Power Techniques

The Java Collections framework is a cornerstone of Java development. It's been a part of J2SE for six years now. Every Java developer knows it—how to create Lists, Maps, and Sets, how to put things into them and take things out, and how to iterate over the contents.

But there's a lot more to the collections framework than that. The basics of the collections classes are so simple that many developers haven't even thought to look for the additional power that's there. And it's not just built-in capabilities, either. The design of the collections framework makes possible several powerful techniques and patterns that can magnify your productivity, as well as helping you build systems that are efficient and scalable.

It may seem strange to give a talk on a framework that every Java programmer already knows. But in every project I've worked on for the past six years, I've seen a lot of code that uses the collections poorly. More often than not, that code was written by skilled programmers with significant Java experience. In this talk, you'll learn how to use the collections well, exploiting their full power—the little-known capabilities, the extensibility features, and powerful patterns such as wrappers, adapters, and decorators. We'll also cover some new features that slipped into Java 1.5, plus a few especially useful third-party collection implementations.

Seaside: A Radical Web Framework

We've been writing web applications now for 10 years, and they're still no fun. They're awkward and clumsy to write. Internally, they're overly complicated (which almost invariably means that they're buggy). Meanwhile, they're usually too primitive externally. To put it another way: the web programming model is so cumbersome for programmers that the users pay—through reduced features, clumsy interaction, bugs, and poor performance.

And it gets worse. The problems are widely known, with the result that seemingly every third programmer in the world has designed a web development framework intended to make things better. There are way too many choices, and few of them have any substantial advantages over the others.

Want to see a better way?

Seaside represents a new generation of web frameworks. Using it, web development is simple. A little code goes a long way. The code is simple and clear. There are powerful development tools that magnify your productivity. You can focus on making your web application good rather than having to strive with all your might just to make it work. It might not be perfect for your situation—it's written in Smalltalk, for one thing, which presents a barrier to adoption in many organizations. And it's not quite as scalable as more traditional web frameworks. But for most applications, it would drastically reduce the development effort while also increasing the usefulness and robustness of the application.

Sound too good to be true? Yeah, I thought so too. But it is true. In this talk, we'll see an extended demo of Seaside, and all the things that make it special. We'll discuss how it works, as well as its limitations. Finally, we'll look at other frameworks that are trying to bring the same ideas and techniques to other languages. Whether you try Seaside or not, a better way of developing web applications is in your future, and Seaside is showing the way.

Software Development Heresies

Much of what you were taught about software development is wrong. Much conventional wisdom is anything but wise. Many of the most loudly heralded technologies are deeply flawed. What's going on? Why does our industry keep bouncing from one new technological or methodological savior to the next? And why do we keep thinking this one's really it? Will we ever learn? Come hear some straight talk about the snake oil you've been sold over the years, and see if you're being sold some more right now. Bring your own stories of programming's misguided movements and hideous hypefests to share with us!

Tag-Oriented JSP Design

Custom tags—not other people's tag packages, but the ones you write yourselves—are extremely powerful tools for JSP-based applications. They can improve your design and clean up your code. Unfortunately, tag-oriented JSP development is underused and undersold. This talk includes a brief intro to the basics of custom tag development, but the focus is deeper: sophisticated tag programming tricks, design techniques, useful ways tags can cooperate with each other, and so on. Learn how to take control of JSP and turn it into a language that really supports your application.

Runtime Code Generation for Java and Beyond

Every now and then, it's really helpful to be able to generate a new Java class at runtime. Some problems just can't be solved any other way. It's one of those troublesome tasks: it's fairly tricky to do, and you only need to do it occasionally—but when you need it, you really need it (and usually you need it yesterday). So you have to start essentially from scratch, learning about how to do it on the fly, under pressure.

This talk is designed to help. You may not face this problem for a while, so there's no point focusing on the arcane details that you'll soon forget. Instead, I'll give you what you'll need to quickly come back up to speed when the time comes. You will see some real bytecode generation, but more importantly we'll discuss the types of problems where runtime code generation can save the day, the variety of tools and techniques that are available, and a step-by-step approach to getting the job done. Finally, for those who may be working with more dynamic languages, I'll show how powerful runtime code generation can be when it's easy.

We'll start simply, but before we're done we'll be pretty deep into the bag of tricks. Come along, and be ready for the next time you need more than what's in your JAR file.

JSR166: Concurrent Programming Utilities for Java 1.5

At long last, Java 1.5 introduces a standard suite of utility classes for concurrent programming. Loosely based on Doug Lea's util.concurrent package, the new java.util.concurrent package specified by JSR166 is different, and improved, in many ways.

This talk covers basic concepts of multithreaded programming and then proceeds with a survey of the new facilities, showing how they can be used to implement common concurrent patterns. You'll learn how to write better, faster, more robust multithreaded Java programs, with fewer debugging woes.

Under the Hood of Java Memory Management

Most of the time, Java's automatic memory management works really well—it's one of the things that makes programming in Java a pleasant and productive experience, and it's nice that we don't have to worry about managing memory manually.

However, although it's usually nice to ignore memory management, occasionally we have to pay close attention. Sometimes we need to take control of certain aspects of memory management. Sometimes Java programs do exhibit memory leaks, or unacceptably long garbage collection pauses, or very poor overall performance. But because Java's memory management is supposed to be fully automatic, it can be difficult to find out what's really going on inside the VM.

Java memory management is just like most labor-saving simplifications: it works well most of the time, but for the weird edge cases when it doesn't work quite right, it can be a nightmare.

This talk opens the hood, examining the inner workings of Java's memory system, including allocation and garbage collection. We'll look at how to control the memory system and interact with it, what's costly and what's not, how to tune the garbage collector and when to switch to a different GC algorithm, and other topics.

Project Infrastructure Values, Principles, and Practices

When we talk about making development projects successful, people tend to focus on architecture and design techniques, modeling tools, new technologies and paradigms of programming, requirements gathering, and methodologies. But sometimes the difference between success and failure comes down to much more mundane issues, like project infrastructure.

Source code control, bug and change management, build automation, test automation, project communication, code organization … all of those things can have a surprising impact on your project. (And if they're done badly, that impact is something you could do without.) Come learn about the kinds of infrastructure that some of the best and most experienced teams use. We'll look at different kinds of infrastructure and why they're all important to a project. We'll also talk about various tools you can use, and their strengths and weaknesses.

Introduction to Aspect-Oriented Programming and AspectJ

Aspect-Oriented Programming is a relatively new approach to solving some of the weaknesses of object-oriented programming. AOP doesn't replace OOP; rather, it complements OOP, melding with object-oriented designs to handle certain issues—certain aspects—that objects don't deal with particularly well. This talk explains the principles of AOP, illustrates the problems it is intended to solve, and introduces the most popular aspect-oriented tool currently available: the Java-based AspectJ system.

Using the Source: Software Archaeology for Users of Open Source Software

One of the most common arguments for open source software is that the source code is valuable and useful. If you need support, bug fixing, or new features, having the source means that you can do it yourself, or pay someone else to do it for you.

Many companies and organizations, however, have difficulty understanding the value. And many that use open source software never take full advantage of the source code, treating open source systems as black boxes very similar to proprietary products. One big reason for this is that most people, even many experienced programmers, find the source code daunting. Studying a large package of someone else's code is difficult, and learning it well enough to find problems, fix bugs, and add features with confidence seems like a big challenge.

In truth, though, it's not as hard as it may seem. This talk will present techniques for exploring software and quickly learning enough about an existing body of code so that you can change it safely and quickly. Examples and tool demonstrations focus on Java-based systems, but the basic principles and techniques aply to most open-source software.