Seminars, Tutorials, and Presentations by Elliotte Rusty Harold

If you're interested in having me reprise any of these presentations for your company, user group, or conference, please see the abstracts page for more details.

By Topic

I've presented most of these seminars and tutorials several times, updating them each time. These are links to the most recent and up-to-date version of each of these talks.

Abstracts

Test Driven Web Applications with HtmlUnit and JWebUnit

Test driven development is the most important low level coding practice since object oriented programming; but it's traditionally the domain of client side code. However, server side web applications can benefit equally well from the principles of test driven development. All that's needed are a few different tools. In particular, we'll explore the HtmlUnit and JWebUnit libraries for developing client side, JUnit based test suites for server side programs. We'll demonstrate in real time the test driven development of a simple web application.

Test Driven Web Applications with FitNesse

Test driven development is the most important low level coding practice since object oriented programming; but it's traditionally the domain of client side code. However, server side web applications can benefit equally well from the principles of test driven development. All that's needed are a few different tools. In particular, we'll explore the Fitnesse framework for developing server side test suites in a Wiki environment and demonstrate in real time the test driven development of a simple web application.

Testing Legacy Code

You've been bitten by the testing bug, are thoroughly test infected. Excellent! You're undoubtedly producing more robust, less buggy software faster and at lower cost. Sadly, it wasn't always this way. You're saddled with a large legacy of untested code. Test first development is not an option. Nonetheless unit testing, JUnit, and test driven development can still dramatically improve your maintenance tasks. Learn strategies for retrofitting test frameworks onto existing code, and developing a test suite for code that never had one before.

Human Factors in API Design

Programmers are human beings too, even if it sometimes seems otherwise to our families. However, programmers are unique in that they have one interface to the computer a typical user doesn’t: the application programmer interface, API for short. Every program has an API. Sometimes this API is exposed to the public when the program serves as a library. Sometimes the API is purely internal, and only seen by other team members working on the same project. But every program has one; and the clearer, more robust, and better documented this API is, the more productive programmers who use the API will be. When designing APis, the same guidelines apply as when designing any other computer-human interface: see and choose is faster than remember and type, modality is bad, the interface should reflect the human's mental model, not the computer's, and so forth. This seminar will apply well-proven human factors principles to the art of API design, and encourage programmers to think about API design in new ways.

Test Driven Development with JUnit

Test first programming is the least controversial and most widely adopted part of extreme programming. It is a critical component of extreme programming, agile development, and continuous integration. Within the Java community, JUnit is the de facto standard test framework. Although nominally designed for unit testing, JUnit is also suitable for functional, acceptance, and integration tests. Similarly, while JUnit was designed to assist programmers writing code with test driven development, it has proven its worth at other stages of the software development process as well. At the analysis and design stage, JUnit helps document what software must do. At the testing stage, JUnit provides a convenient framework for isolating, reproducing, and then fixing the inevitable bugs. Finally, in the maintenance stage, JUnit helps prevent regressions where bugs creep back into software. This class offers attendees a solid, hands-on practical introduction to test driven development in Java and JUnit. Attendees will design, code and test a simple application using JUnit. Along the way they'll learn about assertions, fixtures, test cases, code coverage, and test-driven debugging.

Mac Development with Java

The CEO's kids gave him an iPod for Christmas. Now he's bought a PowerBook, and suddenly you've been assigned to port the company's mission critical client software to the Mac. Fortunately for you, the application is written in Java, so the port won't be that hard. However, truly native look-and-feels require understanding the rules and conventions of the host platform; for instance which menu items go where and what their names are. "Exit" is a conventional menu item on Windows, but to a Mac user it just screams that an application is a Windows port. With the market share of the Mac predicted to double over the next couple of years as due to the iPod Halo effect and frequent Windows security breaches, it's more important than ever for developers to make their applications Mac-savvy. This talk explores the challenges of developing Java applications that are indistinguishable from real, native Macintosh applications. It isn't hard to make an Java application Mac savvy; but you do need to know what's expected. Through demos of both good and bad Java applications running on the Mac, you'll learn what Mac users expect. No prior Mac experience is required.

Testing GUIs with Abbot and Costello

No, this isn't a vaudeville act. Abbot and Costello are open source tools for automating Java GUIs with testing in mind. Abbot enables JUnit tests to interact with and query the user interface, and to simulate user actions. Costello records user actions as scripts that can be played back by test suites. Together, they enable you to perform test-driven development on client-side GUI programs, and write unit tests that access the menus, dialogs, buttons and other widgets in a modern GUI application.

Test Driven Development With Eclipse

Test first programming is the least controversial and most widely adopted part of extreme programming. Within the Java community, JUnit is the de facto standard test framework. Eclipse has wisely made JUnit a core part of its Java development tools. This session introduces test driven development in the Eclipse environment. You'll learn how to write, run, and debug JUnit tests using Eclipse. No prior experience with JUnit is required.

Measuring JUnit Code Coverage

A comprehensive unit-test suite is a necessity for a robust program. But how can you be sure that your test suite is testing everything it should? This seminar will explore different tools and strategies for measuring code coverage and verifying that the tests are actually testing what they're supposed to be testing (and explain what to do when they're not). The result is not only better tested code, but more robust, reliable, bug-free programs.

JUnit: A Hands-On Introduction for Testers

JUnit is the de facto standard test framework for Java. It is a critical component of extreme programming, agile development, and continuous integration. Indeed without the foundation provided by JUnit, these development styles really couldn't function. Although nominally designed for unit testing, JUnit is also suitable for functional and integration testing. Similarly, while JUnit was designed to assist programmers writing code with test driven development, it has proven its worth at other stages of the software development process as well. Elliotte Rusty Harold offers attendees a solid, hands-on practical introduction to test driven development in Java with the JUnit framework. Attendees will develop a simple application using test-first techniques and learn about assertions, fixtures, test cases, code coverage, and test-driven debugging.

Macifying SWT

The CEO's kids gave him an iPod for Christmas. Now he's bought a PowerBook, and suddenly you've been tasked with porting the company's mission critical client software to the Mac. And by the way, if you could have this done last Tuesday, it would be really appreciated. Fortunately for you, the application is written in Java using the SWT, so the port won't be that hard. However, truly native look-and-feels require understanding the rules and conventions of the host platform; for instance which menu items go where and what their names are. "File/Exit" is a conventional menu item on Windows, but to a Mac user it just screams that an application is a Windows port. With the market share of the Mac predicted to double over the next couple years as a result of the iPod Halo effect and frequent Windows security breaches, it's more important than ever for developers to make their applications Mac-savvy, even if they themselves are Windows or Linux users. This talk explores the challenges of developing SWT application that are indistinguishable from real, native Macintosh applications. It covers all the points the SWT doesn't: menu item names and placement, menu accelerators, button labels, double-clickable applications, disk image files, and more. It isn't hard to make an SWT application Mac savvy; but you do need to know what's expected. Through demos of both good and bad SWT applications running on the Mac, you'll learn what Mac users expect, and how to fulfill those expectations. No prior Macintosh experience is needed.

Static Code Analysis With Eclipse

Static code analysis tools are a cheap, easy, and fun way to find lurking bugs and design flaws in your Java programs. These tools won't find all the bugs in a code base, and they're not very helpful with debugging a known problem, but they excel at uncovering bugs you weren't even looking for. Automatically detectable problems include stylistic problems such as excessively long lines and methods that don't adhere to naming conventions, performance hot spots such as concatenating strings, internationalization problems like calling toUpperCase() without a locale, and major flaws such as overriding equals() without overriding hashCode(). Sometimes the problems detected by these tools are trivial, but sometimes they're symptoms of nasty undiscovered bugs. This talk will demonstrate and discuss a number of static code analysis tools for Java including FindBugs, PMD, lint4j, and checkstyle.

What's New in JUnit 4

JUnit 4 is the first release of the preeminent Java testing framework in three years, and the most major release since JUnit 1. While maintaining backwards compatibility with existing test suites, it offers a completely new, simplified framework for unit testing Java code based on Java 5 annotations. Setup and tear down code is now much more configurable, and no longer needs to run before and after each single test. Exception testing is much more straightforward. Test classes can now extend your own classes instead of TestCase; and test methods no longer all have to be named "testFoo." Come hear all the latest news about the next generation in Java unit testing.

Top Ten Myths about Java I/O

I/O is one of the most widely misunderstood areas of the Java API, not because it's hard but because it's different. This talk explores some of the common misconceptions about Java I/O and corrects them. Along the way you'll learn how to do some things you probably thought Java couldn't do and how to avoid some of the traps and pitfalls that lay in wait for the unwary programmer.

Refactoring Java

Over the last few years, refactoring, the process of gradually improving a code base by renaming methods and classes, extracting common functionality into new methods and classes, and generally cleaning up the mess inherent in most 1.0 systems are has gained a lot of adherents. Integrated Development Environments like Eclipse and IDEA can now automatically refactor code. But what if it's not just your code that needs refactoring? What if the language itself has inconsistencies, inefficiencies, and just plain idiocies that need to be corrected? When you get right down to it, the entirety of Java is really just like any other large code base. It has some brilliant parts, some functional parts, and some parts that make just about everyone scratch their heads and ask, "What the hell were the developers thinking?"

It's now a little more than eleven years after James Gosling began working on OAK, the language that would eventually become Java, and seven years since Sun posted the first public release of Java. The language, class library, and virtual machine collectively known as "Java" are all showing their age. There are many parts of Java that everyone agrees should be fixed, but can't be for reasons of backwards compatibility. Until now revisions of Java have attempted to maintain "upwards compatibility"; that is, all earlier code should continue to run unchanged in later versions of Java. This has limited the changes that can be made to Java, and prevented Sun from fixing many obvious problems.

This talk explores the possibilities for a new Java 3 that jettisons the baggage of the last decade, and proposes numerous changes to the core language, virtual machine, and class libraries. Among other topics, we'll look at primitive data types, threads, the collections API, arithmetic, bitwise operations, class loaders, Unicode support, Swing and the AWT, XML, I/O, and more.

Introduction to Java I/O (1.5 hours)

I/O is one of the most widely misunderstood areas of the Java API, not because it's hard but because it's different. The Java I/O libraries have one of the cleanest, simplest designs of any common programming language, but that design is unfamiliar to most programmers. In this seminar you'll learn how to perform fast, efficient I/O that works with Java instead of against it. Topics covered include input and output streams, filter streams, readers and writers, and the crucial differences between text and binary I/O.

Java 1.4 and Beyond

Now that Java 1.3 has been officially released, it's time to explore both where Java is going in the future and where it should go (which may or may not be the same place). What's ahead for the Java language and libraries? Will Java ever get templates, operator overloading, and multiple inheritance? Perhaps more to the point, should it get these constructs? Will Java I/O ever be fast enough for data intensive work? Will your network programs be allowed access to the raw IP layer so ping or traceroute can be written in Java? Hear one outside oracle's predictions for the future of Java.

Java Network Programming, Part 1: URLs, URLConnections, and InetAddresses

This talk shows you how to use Java's URL and URLConnection classes to download data and content from Internet servers. You'll learn how the URL and URLConnection classes are integrated with Java's content and protocol handlers. You'll also learn how you can use these classes to communicate with CGI programs on a web server. Possible applications include web spiders, link checker robots, and persistent server-side storage.

Java Network Programming, Part 2: Sockets, Server Sockets, and UDP

Sockets are a powerful abstraction that let you communicate with remote network hosts as easily as you'd read or write a file on your hard drive. This talk shows you how to take advantage of Java's Socket and ServerSocket classes to communicate with any TCP server or client. Possible applications include both standard protocols for email, ftp, and news, and custom protocols for networked multiplayer games, interactive chat, whiteboards, and more.

Web Client Programming with Java

Java is the first major programming language designed for network applications from the start. This seminar teaches you all about client-side network programming in Java with a particular emphasis on the World Wide Web, HTML, and HTTP. You'll see how to use Java's InetAddress, URL, and URLConnection classes to download data and content from Internet servers. You'll learn how the URL and URLConnection classes are integrated with Java's content and protocol handlers. You'll also learn how you can use these classes to communicate with CGI programs on a web server. Possible applications include web spiders, link checker robots, and persistent server-side storage. Finally, we'll talk about HTML, one of the most common and yet most non-standard data formats on the Web. You'll learn how to use Swing to display HTML. Possible applications include web browsers, robots, spiders, search engines and similar tools.

Java: Hope vs. Hype

It's become clear that Java is the most hyped programming language in history. In a little under two years since it's first release over 300,000 programmers have begun using it, and this growth shows no sign of stopping. Never before has a language caught on so quickly. However with such fast growth, it should come as no surprise that not all the pieces are in place yet. Many people are moving to Java based more on their hopes for what the language will do in the future than what it actually can do today. In this talk, we'll explore the hype and the hopes that got programmers excited about Java in the first place, and discuss how the language is and is not living up to those hopes.

By Venue

Software Development Best Practices 2006

Architecture & Design 2006

Software Development West 2006

Weekend with the Experts

Capital District Java Developers Network

STARWest 2005

EclipseWorld 2005

STPCon 2005

Software Development Best Practices 2005

Software Development West 2003

Javapolis 2002

International Java Developer's Conference 2001

UK Unix User's Group

Software Development East 2000

O'Reilly Java Conference 2000

Software Development West 2000

Georgia Software Developer's Conference 2000

Atlanta Java User's Group

Internet World 2000

Software Development East 1999

CityJava

Software Development West 1999

Software Development East 1998

Software Development West 1998

Fordham University


[ Cafe Au Lait | Mailing Lists | FAQ | Tutorial | Course Notes | User Groups ]

Copyright 1999-2007 Elliotte Rusty Harold
elharo@metalab.unc.edu
Last Modified February 21, 2007