Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to have some basic ideas about bug-tracking in your toolbox. Learn to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.

Learn to use jdb, jconsole, jps, jstat, and other tools to identify and squash software defects that just won't reveal themselves during development. Then, just in case those tools aren't enough for you, we'll look at how to write your own, special-purpose tools using the same technology backplane.

Crashes? Outages? Slow response? We all know that it's never your code that causes these things, but for some reason those pesky system administrators still insist on paging you at 4AM to come in and fix those problems, anyway. For some reason, they just keep expecting you to support this thing, even after QA said it was OK!

In this presentation, we'll talk about some of the reasons why monitoring in a production application is so important, and why it's not just a system administrator concern. Next, we'll talk about some simple monitoring facilities that don't require any new APIs or new libraries, yet still deliver some useful monitoring capabilities to developers, sysadmins and management. Next, we'll look at using JMX tools to keep an eye on what's going on inside of the JVM itself and/or your applications server, then how to use JMX to create your own points of monitoring interest. Finally, we'll look at how system administrators can build their own monitoring tools by using languages like Groovy and/or JRuby as the ultimate JMX client. And, for the really hard-core, we'll even take a look at how to use tools like JVMTI and/or java.lang.instrument to write custom monitoring agents.

Wondering why your enterprise Java app just... sucks? Trying to figure out why you can't get more than 10 concurrent users online at the same time? Looking for ways to try and spot the slowdowns and ways to fix them?

In this talk, we'll look at the various things that can occur in an enterprise Java app (from the smallest web site to the largest multi-resource environment) to make your Java apps perform and scale less well than they should, and how you can work to correct them. We'll examine a variety of broad concepts to apply in architecture and design, and examine what factors make an enterprise application slow, then use a variety of tools to figure out how to remedy them.

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play.

In this presentation, we'll examine several of the "hackable" customization points inside the JVM: the boot classpath, allowing us to add or modify existing JDK classes without violating the license agreement; the JNI Invocation API, allowing us to create custom Java launchers to establish an environment for the JVM that corresponds to exactly the way we want it; or even replace core Java classes with our own versions. Innocents beware--we're a long way from "Hello, Java". (Attendees should have some familiarity with C/C++ code and native build practices to get the most out of this talk.)