This page lists some of the Java talks I've given in the past and am willing to give in the future. Talks range from an hour to all day. The duration of most of these talks can be expanded or contracted as necessary to fit your needs. I also have a large repetoire of XML talks, many of whcih also involve Java.
If you'd like me to speak at your conference or to your company, just drop an email to me at elharo@metalab.unc.edu and we'll see what we can set up. I'm based in New York, but I do travel quite a bit. I also do a lot of speaking about XML as well. I'm constantly developing new presentations on a variety of subjects related to XML, Java, and the Web so if there's a particular topic you'd like to hear me pontificate about, feel free to ask. For example, it would be straight-forward to do a seminar on the Java Collections API or Multithreading in 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.
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.
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.
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 Swing applications running on the Mac, you'll learn what Mac users expect. No prior Mac experience is required.
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 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. Eclipse itself can detect and flag numerous problems such as unused private fields, unused imports, empty catch blocks, non-localized strings, doc comments that don't match their associated methods, and more. This talk will discuss the various static code analysis options for Java in Eclipse. We'll also explore what third-party plug-ins like FindBugs, PMD, JLint, and checkstyle can provide that Eclipse itself doesn't.
More and more software development work requires handling XML. Everything from Ant build files to WSDL documents describing network services are implemented as XML. Test cases and output can often be most conveniently stored as XML. The default install of Eclipse includes a rudimentary XML editor. Third party plug-ins add much more sophisticated editing abilities, as well as other tools such as XSL transformers, schema validators, schema editors, and more. This session will demonstrate the latest plug-ins for working with XML in Eclipse.
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.
Prerequisites: Basic Java
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.
Prerequisites: Basic Java
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.
Prerequisites: Basic Java
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.
Prerequisites: JUnit Experience
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.
Prerequisites: Intermediate Java, including Swing
Although JUnit has become the de facto unit testing framework for Java, it has its idiosyncracies, performance issues, and just plain weirdnesses. This talk explores TestNG, an alternative open source unit testing framework based on Java 1.5 annotations (or Java 1.4 JavaDoc) that is more flexible and configurable than JUnit. Notable features include the ability to run tests in a particular order, and to not constantly rerun expensive initialization code. We'll compare the two products and discuss both the strengths and weaknesses of each in order to figure out which tool is appropriate for which projects and teams.
Prerequisites: JUnit Experience
Artima SuiteRunner is an open source testing toolkit that adds much useful functionality to JUnit. Reporters collect and present test results in a variety of formats such as text, graphics, web pages, databases, XML, and email. Runpaths load test classes from files, directories, and/or URLs. Recipe files capture and save the properties of a run of a particular test suite for easy reuse. This talk introduces SuiteRunner and shows how to use it both as an add-on to or a replacement of JUnit.
A single carpenter using power tools and a pickup truck can be many times more productive than a team of carpenters working with saws, hammers, and wheelbarrrows. No professional carpenter working today would consider doing a job without power tools. Software development may be a modern industry, but its very newness means many are programmers are still working with the software equivalent of the manual saw and the wheelbarrow. XOM is a Java library for processing XML that has been written by a single programmer working part time that competes with libraries written by large teams of full-time paid developers. When programmer time is tight and resources are limited, it becomes more important than ever to use the most effective tools and techniques available. This talk discusses the lessons learned while working on XOM with a particular emphasis on the tool chain. We'll discuss and demonstrate profilers, debuggers, refactories, code coverage tools, static analyzers, spell checkers, version control systems, build automation, and more. You'll see how the right choice of tools enables you to write faster, more robust, less buggy code much more quickly than you could with traditional manual techniques. I promise everyone will add at least one new power tool to their programmer toolbox that can enhance their productivity immediately.
The toner may be starting to dry on the Java 5.0 specification, so it's time to start thinking about the next releases of Java, code named Mustang (Java 6.0) and Dolphin (Java 7.0). What's ahead or the Java language and libraries? Will Java ever get operator overloading or multiple inheritance? Perhaps more to the point, should it get these constructs? Will network programs finally be offered access to the raw IP layer so ping or traceroute can be written in Java? Will methods and classes deprecated eight years ago finally be removed? And will the Java source ever be opened up? Let's break out the crystal balls, leap right off the bleeding edge, and explore both where Java is going in the future and where it should go (which may or may not be the same place).
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.
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.
This talk assumes attendees are familiar with basic Java and object oriented programming techniques including classes, inheritance, and polymorphism.
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.
This talk assumes attendees are familiar with basic Java and have done some programming that involves I/O streams.
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.
Attendees should be familiar with basic Java and object oriented programming techniques. They should also have done at least a little GUI and event driven programming in Java using the AWT or Swing.
Java 2 contains some powerful little known classes that make building web browsers, robots, spiders, search engines and similar tools extremely simple. In fact it's possible to build a complete HTML 3.2 Web browser in about 40 lines of code! This talk explores Java 2's HTML parsing and display classes. Topics covered include:
Attendees should be familiar with basic Java and object oriented programming techniques. They should also have done at least a little GUI and event driven programming in Java using the AWT or Swing.
Java is the first major programming language designed for network applications from the start. This tutorial teaches you all about network programming in the Java environment. You'll learn how to write fast, cross-platform, multithreaded clients and servers. 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.
You'll also learn about Java's low-level socket classes for more intimate contact with the network. You'll learn to take advantage of Java's Socket and ServerSocket classes to communicate with TCP/IP servers and clients. You'll also learn about the UDP protocol for fast, unreliable data transfer. Possible applications include both standard protocols for email, ftp, and news, and custom protocols for networked multiplayer games, interactive chat, white boards, and more.
This talk assumes attendees are familiar with basic Java programming including input and output streams, and have a user's view of the Internet. (e.g. they can send email and browse the web.)
Java is the first major programming language designed for network applications from the start. This tutorial teaches you all about network programming in the Java environment. You'll learn how to write fast, cross-platform, multithreaded clients and servers.
The course begins with a discussion of the basic I/O libraries that form the foundation for network programming in Java. You'll learn how input and output streams are meant to be used. You'll learn to use the Reader and Writer classes to handle text without assuming that everything is ASCII. And you'll learn to take advantage of filter streams to make text and data processing simpler.
Next 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.
You'll also learn about Java's low-level socket classes for more intimate contact with the network. You'll learn to take advantage of Java's Socket and ServerSocket classes to communicate with TCP/IP servers and clients. You'll also learn about the UDP protocol for fast, unreliable data transfer. Possible applications include both standard protocols for email, ftp, and news, and custom protocols for networked multiplayer games, interactive chat, white boards, and more.
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 both parse and display HTML. Possible applications include web browsers, robots, spiders, search engines and similar tools.
This course assumes attendees are familiar with basic Java programming and have a user's view of the Internet. (e.g. they know how to surf the Web, publish HTML, and send email).