Ted Neward - Author of Server-Based Java Programming and Effective Enterprise Java

Ted Neward is an independent consultant specializing in high-scale enterprise systems, working with clients ranging in size from Fortune 500 corporations to small 20-person shops. He speaks on the conference circuit, including the No Fluff Just Stuff Symposium tour, discussing Java, .NET and XML service technologies, focusing on Java-.NET interoperability. He has written several widely-recognized books in both the Java and .NET space, including the recently-released "Effective Enterprise Java". He lives in the Pacific Northwest with his wife, two sons, two cats, and eight PCs.

• Enterprise Performance and Scalability
• The Busy Java Developer's Guide to Reflection
• The Busy Developer's Guide to Rules and Rules Engines Using JESS
• The Busy Java Developer's Guide to Debugging and Monitoring
• The Busy Java Developer's Guide to java.util.concurrent
• The Busy Java Developer's Guide to Threads and Synchronization

Enterprise Performance and Scalability
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.

The Busy Java Developer's Guide to Reflection
If you've never used Reflection (java.lang.reflect), you don't know what you're missing. In this presentation, we'll take a code-first, soup-to-nuts look at the Java Reflection APIs, from how to examine the class metadata that Reflection provides, to using annotations to enhance that metadata with your own information, even through the use of Java Dynamic Proxies to create flexible object "interceptors" that can layer services in front of ordinary method calls with nothing more complicated and an interface and a factory.

The Busy Deveoper's Guide to Rules and Rules Engines Using JESS
If you've been keeping your ear to the ground, you may have heard some talk recently about "rules", "business rules" and "rules engines", but not necessarily any clear discussion on what they are, how to use or design them, or why they might be useful or important.

This presentation puts some concrete definition around what a "rule" is, how a "rule engine" like JESS (Java Expert System Shell) can enable your users to be more agile than they ever thought possible, where JSR-94 fits into both the J2EE and "lightweight" development environments, and how you can (finallY!) get out of the "infinite if-else game".

The Busy Java Developer's Guide to Debugging and Monitoring
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 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.

The Busy Java Developer's Guide to java.util.concurrent
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 Executors, the Barriers, and more, and more importantly, how and when developers should use these constructs to write thread-safe code.

The Busy Java Developer's Guide to Threads and Synchronization
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 Thread API, and more importantly, discuss what really happens when you mark a method as "synchronized" and why the Java developer needs to know... and care. We?ll cover java.lang.Thread API, daemon threads, thread priorities, object monitors and ?synchronized?, wait/notify/notifyAll, and more.