Why the Next Five Years Will Be About Languages
Thanks to the plateau of per-chip performance increases and the resulting need to work better with multi-core CPUs, the relative difficulty of mapping user requirements to general-purpose programming languages, the emergence of language-agnostic "virtual machines" that abstract away the machine, the relative ceiling of functionality we're finding on the current crop of object-oriented languages, and the promise and power of productivity of dynamically-typed or more loosely-typed languages, we're about to experience a renaissance of innovation in programming languages. Come hear why this is, and what practicing programmers need to do in order to ride the forefront--instead of the trailing edge--of this new wave in computer science. (For any audience, recommended as a keynote presentation.)

Rethinking "Enterprise"
The era of the big, heavy, transactionally-oriented client/server topology, as best described by the J2EE Specification and Blueprints document, seems to be over. The era of the lightweight, transactionally-oriented client/server topology seems to be at its zenith. Is this really where we want to be when building enterprise systems? And how did we end up here, anyway? What's the new "enterprise" developer supposed to do? (For any audience, recommended as a keynote presentation.)

Pragmatic Architecture
Building an application is not the straightforward exercise it used to be. Decisions regarding which programming languages to use (Java, .NET, even FoxPro), which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)... it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, Windows Presentation Foundation, SWT, Swing, WinForms, Struts, WebForms, Ajax, RMI, .NET Remoting, JAX-WS, ASMX, Windows Communication Foundation, Windows Workflow Foundation, JMS, MSMQ, transactional processing, and more. After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more. (For any intermediate audience, recommended as a keynote or a half-day or full-day tutorial.)

Pragmatic XML Services
A lot has been said about service-orientation and SOA, but precious little of it describes the actual, concrete practice of building services that interoperate via the use of XML. In this talk, we will present a down-to-earth concrete discussion of building services, the reasons for doing so, and the tools by which building services can be made easier, all with an eye towards actual working interoperability with .NET, Java and Ruby clients and servers. Particular emphasis will be laid on versioning and evolution, incrementally growing the service to include "big name" topics like reliability and security, and how to avoid having to pay huge up-front costs in your design to accomodate those features later, including how REST and SOAP can peacefully coexist and supplement one another. (For any intermediate audience with background in one of .NET, Java or Ruby, as a keynote, 90-minute session, half-day or full-day tutorial. Please specify your audience's background when scheduling.)

Pragmatic Messaging: A flexible, powerful, and extensible communication model
Over the last decade, focus in inter-process communication has centered on Remote Procedure Calls (RPC) and its object-oriented equivalents. In this talk, we'll discuss the benefits of using another communication approach, messaging, to gain flexibility, scalability, extensibility, and other integration benefits that traditional RPC simply can't provide. We'll even talk about various messaging technologies and how they all relate to one another, including (but not limited to!) MSMQ, JMS, SOAP, and REST, among others. (For all audiences, recommended as a keynote, 90-minute presentation, half-day or full-day tutorial. Please specify your audience's background when scheduling.)

Pragmatic Interoperability: Making Java and .NET play well together
Java and .NET represent the lion's share of enterprise development. In this talk, learn how the two environments can interoperate with one another, not only over web services, but also via in-process channels and other methods. Along the way, we'll talk about how to leverage the strengths of each, such as using Microsoft Office to act as a "rich client" to a Java middle-tier service, or building a Windows Presentation Foundation GUI on top of Java POJOs, or even how to execute Java Enterprise/J2EE functionality from within a Windows Workflow host. (For either a .NET and/or Java audience, as a 90-minute presentation, half-day tutorial or full-day tutorial. Please specify your audience's background when scheduling.)

Busy Java Developer's Guide to Scala
Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Clojure
Clojure is a dynamic programming language, targeting the JVM. Designed to be a general-purpose language, it combines the approachability and interactive style of a scripting language with an efficient and robust infrastructure for multithreaded programming. As a dialect of Lisp, it shares the code-as-data philosophy and provides a powerful macro system, but runs as compiled bytecode. In this presentation, we'll look at the basic syntax of Clojure, the feature set provided (including software transactional memory and a reactive Agent system, as well as immutable persistent data structures for easier concurrent programming), and how to use it in your current Java applications. (For any Java audience, as a 90-minute, half-day, or full-day presentation.)

Busy .NET Developer's Guide to F#
F# represents Microsoft's entry into the functional programming world, and for many .NET developers it represents both an opportunity and a challenge. Opportunity, in that functional programming can make a whole range of tasks much, much easier; challenging, in that functional programming represents an entirely new way of looking at how to think about designing and writing .NET code. In this presentation, we'll examine the syntax of F#, see how it maps to the underlying CLR concepts, talk about how F# implements functional concepts without losing many of the benefits of object orientation, and finally, how it can be used to make the CLR developer's life much easier. (For any .NET audience, as a 90-minute, half-day or full-day presentation. Strongly recommended as at least a half-day presentation or in two 90-minute presentations.)

The Busy Java Developer's Guide to JRuby
Looking for ways to extend your Java programming skills in the dynamic direction without abandoning the platform you've come to love? JRuby, an open-source implementation of the Ruby programming language on top of the Java Virtual Machine, offers exactly that option: Ruby language and Java platform, bringing together two of the most exciting and powerful concepts of the 21st Century. Come learn a little Ruby and how it maps to the JVM in this introductory, code-first overview both the Ruby language and the JRuby implementation. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to JRuby MOP
JRuby's biggest advantage over Java isn't in its simpler syntax or support for closures. It's in its Meta-Object Protocol, a fancy academic term for saying "We can do really powerful things to objects and classes at runtime without requiring a recompile." In this presentation, we'll tear into the JRuby MOP, exploring how to do things that most Java programmers didn't even know was possible. Once we've done that, then we'll tackle what's useful, what's powerful, and what's just plain scary. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Groovy
Looking for ways to extend your Java programming skills in the dynamic direction without abandoning the platform you've come to love? Groovy, an open-source programming languages being ratified through the Java Community Process as we speak, is a dynamic language with both interpreted and compiled execution modes, complete access to the underlying Java platform and libraries, and a lot of the features that we've come to love in languages like Ruby and Python. Come find out what Groovy can do for you through this introductory, code-first overview. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Groovy MOP
Groovy's biggest advantage over Java isn't in its simpler syntax or support for closures. It's in its Meta-Object Protocol, a fancy academic term for saying "We can do really powerful things to objects and classes at runtime without requiring a recompile." In this presentation, we'll tear into the Groovy MOP API, exploring how to do things that most Java programmers didn't even know was possible. Once we've done that, then we'll tackle what's useful, what's powerful, and what's just plain scary. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Jaskell
Jaskell is a lazy functional scripting language for Java, featuring higher-order functions, function currying, string interpolation, lazy evaluation, a simple syntax, and more. In this presentation, we'll take a look at the Jaskell syntax, its functional feature set, and talk about functional programming in general and how--in some cases--it can be more powerful than traditional object approaches. We'll continue with a glance at Jet, Jaskell's equivalent to JSP, and Neptune, a functional approach to Ant build files. Finally, we'll conclude with a quick introduction to building DSLs in Jaskell, including a simple rules engine "cre", that ships with the Jaskell source bits. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Developer's Guide to ECMA(Java)Script
ECMAScript, better known by its original name, Javascript, remains one of the most popular--and misunderstood--programming languages in use today. While most developers see Javascript as a crippled form of its namesake (Java), it turns out that ECMAScript represents a powerful dynamically-typed language, easily equal to the other popular dynamic languages of the day (Python or Ruby). In this presentation, we'll take a fresh look at the ECMAScript language, examine its basic structure and syntax, and look at how it manages objects internally. Then, with the basics out of the way, we'll start to examine the more interesting parts of the language, and wrap up with some discussion of how ECMAScript can be integrated into more than just a web browser to provide extension capabilities. (For either a .NET audience using the JScript.NET compiler, or a Java audience using the Rhino implementation, as a 90-minute or half-day presentation.)

The Busy Developer's Guide to ECMA(Java)Script 4
ECMAScript, better known by its original name, Javascript, remains one of the most popular--and misunderstood--programming languages in use today. While most developers see Javascript as a crippled form of its namesake (Java), it turns out that ECMAScript represents a powerful dynamically-typed language, easily equal to the other popular dynamic languages of the day (Python or Ruby). And now, it's getting a completely new facelift, the first this millenium, and a whole slew of new features to boot. In this presentation, we'll take a look at the ECMAScript 4 proposal, including the new gradual type system, namespaces and packages, union types, generic functions, and reflection. (For any audience familiar with ECMAScript 3, as a 90-minute or half-day presentation. Strongly recommended as a "part 2" to "The Bsy Developer's Guide to ECMA(Java)Script".)

The Busy Developer's Guide to E4X: XML and ECMAScript, Bringing Dynamic Language and XML to Life
ECMAScript has gotten a facelift recently, a new variant of the language called "E4X" that incorporates some exciting and powerful XML-related features directly into the language, like XML literal syntax, simplified XPath navigation using object access, and more. In this presentation, we'll examine the E4X extensions to ECMAScript, including basic syntax and computation, and how they can be used to simplify your XML interactions. (For any audience, as a 90-minute or half-day presentation.)

The Busy .NET Developer's Guide to PowerShell
Microsoft initially introduce the PowerShell command-line shell as a new tool for system administrators who were looking for a Windows equivalent to the powerful command-line script shells popular in the UNIX world, but in addition to making PowerShell .NET-aware, they also made PowerShell hostable from any .NET environment--including your own applications. In this presentation, we'll look at the PowerShell dynamic language, its deep integration with .NET, and how .NET developers can use this not only to build .NET applications, but extend their applications for others to customize and enhance. (For intermediate .NET audiences, a 90-minute presentation.)

The Busy Java Developer's Guide to Annotations
Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5). (For an intermediate Java audience, as a 90-minute presentation.)

Extend the Customization Possibilities of Your Java App with Scripts
Ever wished you could just put parts of your program in end-users' hands and let them build the infinite little changes they want? Ever thought about how you might make your application more robust by writing less code, not more? Embed a scripting engine into your application--complete with the safeguards necessary to ensure that users can't do anything they shouldn't be able to--and release yourself from the Principle of Perpetual Enslavement. This presentation will describe how to embed a scripting engine using BSF and/or Java6, discuss the pros and cons of the various ones available, and how to put enough safeguards around the scripts to make sure that your application can't be hijacked by bad users' scripts. (For any intermediate Java audience, as a 90-minute presentation. Ask about the possibility of delivering it as a half-day or full-day tutorial.)

Extend the Customization Possibilities of Your .NET App with Scripts
Ever wished you could just put parts of your program in end-users' hands and let them build the infinite little changes they want? Ever thought about how you might make your application more robust by writing less code, not more? Embed a scripting engine into your application--complete with the safeguards necessary to ensure that users can't do anything they shouldn't be able to--and release yourself from the Principle of Perpetual Enslavement. This presentation will describe how to embed a scripting engine, discuss the pros and cons of the various ones available, and how to put enough safeguards around the scripts to make sure that your application can't be hijacked by bad users' scripts. (For any intermediate .NET audience, as a 90-minute presentation. Ask about the possibility of delivering it as a half-day or full-day tutorial.)

The Busy Developer's Guide to Building Your Own Language (for the CLR)(for the JVM)
Ever wanted to truly explore what it would be like to be a James Gosling, or a Bjarne Stroustrup, or Anders Hjalsberg? Want to see what it's really like, building a language from soup to nuts? This presentation will take you through that process exactly, from deciding whether your language will be compiled or interpreted, or static- or dynamically-typed, through defining a simple grammar, building the parser, constructing the AST, and generating code out the back end. We'll look at tools that can simplify this process, and discover that building a custom language for a particular task isn't quite as hard as it might seem at first. It's domain-specific languages, without the MDA. (This presentation can be given to an intermediate audience of either .NET-oriented or Java-oriented presuasion; please specify the preference ahead of time. For any intermediate audience, as a 90-minute, half-day or full-day session.)

Effective Enterprise Java
Listen to some of the 75 Items from the book of the same name, providing rules for building enterprise Java systems that will scale, will perform, will extend and reify as your business needs evolve, and most of all, won't suck. Items fall into 7 major categories: Architecture, Processing, State Management, Communication, Security, System, and Presentation, and range in scope from "Pregenerate content when possible" to "Establish a threat model" and "Keep your data and processors close together". (For intermediate Java audiences; a subset can be delivered in a 90-minute, half-day or full-day session.)

The Busy .NET Developer's Guide to Windows Workflow
For enteprrise .NET developers, WinWF promises to bring a new era of power and capability in an area previously unexplored, by encouraging us to build systems that model workflow as a first-class activity, not as an ad-hoc afterthought managed with clumsy database tables or expensive vendor products. This presentation explores the technical underpining of Windows Workflow, including how to write a custom activity, how to string activities together into a workflow, and how and when you would integrate WinWF into your enterprise systems. (For any .NET audience, as a 90-minute or half-day session.)

The Busy .NET Developer's Guide to Rules and Rules Engines (Using nxbre) (Using Drools.NET)
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 ... can enable your users to be more agile than they ever thought possible, where it fits into both the WCF/WF/BizTalk and "lightweight" development environments, and how you can (finallY!) get out of the "infinite if-else game". (For any .NET audience, as a 90-minute or half-day session. This session can also be delivered using Drools.NET.)

The Busy Java Developer's Guide to Rules and Rules Engines (Using JESS) (Using Drools)
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". (For any Java audience, as a 90-minute or half-day session. This presentation can also be delivered using Drools.)

The Busy Java Developer's Guide to Java Bytecode
Java bytecode is the code set used by the Java runtime (the JVM) that is JIT-compiled into native code at runtime. Find out how to read (and write) JVM bytecode directly, so as to better understand how the runtime works, and be able to disassemble key libraries that you depend on. We'll even take a look at the new bytecode instructions being debated for introduction in JDK 1.6 (Mustang), and how they might behave and operate. We'll also tackle examining tools and libraries that can be used to manipulate Java bytecode directly, such as Javassist, ASM and BCEL, and why and when you might do this. (For any intermediate Java audience, as a 90-minute presentation.)

The Busy Developer's Guide to CIL
CIL (Common Intermediate Language) is the execution code set used by the .NET runtime (the Common Language Infrastructure, or CLI) that is JIT-compiled into native opcodes at runtime. Find out how to read (and write) IL code directly, so as to better understand how the runtime works, learn what new type features were introduced in the .NET 2.0 release to support generics, and be able to disassemble key libraries, without the source, that you depend on. (For any intermediate .NET audience, as a 90-minute presentation.)

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, end-to-end 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. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy .NET Developer's Guide to Reflection
If you've never used Reflection (the System.Reflection namespace) before, you don't know what you're missing. In this presentation, we'll take a code-first, soup-to-nuts look at the .NET Reflection APIs, from how to examine the type metadata baked within every .NET assembly, to using custom attributes to enhance that metadata with your own information, even through the use of CodeDOM and Reflection.Emit to generate code (either at runtime or at build-time). Reflection represents one of the most powerful parts of the .NET environment; don't fail to exploit it just because you don't understand it. (For any beginning to intermediate .NET audience, in either C# or Visual Basic, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Platform Security
Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, and more. Never again will you be happy with the basic policy file, or with running code without the full power of the Java platform security model behind you. (For an intermediate Java audience, as two 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Advanced Platform Security
So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place. (For an intermediate Java audience, as a 90-minute; note that this presentation assumes developers are familiar with the topics covered in "The Busy Java Developer's Guide to Platform Security".)

The Busy Java Developer's Guide to JAAS
Role-based security and permissions based on individuals, rather than code, is a necessary component to building secure systems. Impersonation, where code takes on the security context of an individual even on machines where that individual is not logged on, helps simplify security execution on server-class machines. In this presentation, we will examine JAAS, the Java Authentication and Authorization Service, and how it can provide single sign-on capabilities, as well as provide secure execution context in any application server or container. Reach beyond simple JSP login pages, to find a better, more comphrensive, and simpler, way to Java code security. (For an intermediate Java audience, as a 90-minute; note that this presentation assumes developers are familiar with the topics covered in "The Busy Java Developer's Guide to Platform Security".)

The Busy Java Developer's Guide to ClassLoaders
If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Deployment
The Java Virtual Machine is an amazing software platform, particularly in the areas of deployment. Thanks to its flexible code-loading scheme (ClassLoaders), Java can run in a variety of different environments and under different contexts. In this talk, we'll start with some of the basics of deployment, like JAR files, and work our way up through a variety of ideas, such as using custom ClassLoaders to load code from a user-defined location, finding resources without having to know their exact path, the Service API, JavaWebStart, and a taste of OSGi. By the time we're finished, you'll never look at deploying Java code the same way again. (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Java Concurrency (parts 1 and 2)
Java was the first "mainstream" platform to include threading as a core facility of the JVM, which means that it also incorporates a synchronization mechanism. In part 1 of this 2-part presentation, we go over the core Java threading support, the historical difference of "native" vs "green" threads (and why it matters today), and how Java5 introduced a number of useful abstractions to help make spinning up and using Threads much, much easier than the basic Thread class provides. Of course, multiple threads means concurrent access, and that means potential corruption if we don't protect the code somehow. In part 2 of this 2-part presentation, we first explore Java's object monitors, and how they provide atomic access. Then we'll examine Java's wait/notify signaling mechanism, built on top of the monitor concepts. Once we're through the basics, it'll be self-evident that this kind of low-level approach is sometimes awkward to use, and how the Java5 concurrent library offers up some higher-level--and easier-to-use--facilities. (For any beginning to intermediate Java audience, as 2 90-minute presentations or a half-day tutorial.)

The Busy .NET Developer's Guide to Joins
Microsoft Research (MSR) is a group of smart folks dedicated to building interesting tools and libraries. In this talk, we'll focus on the Joins library, a library based loosely on the join calculus (from academia) and the C-omega research language (from Microsoft Research), that makes building thread-safe applications much, much easier. Requiring nothing more than "using Microsoft.Research.Joins", you can quickly create powerful thread-safe concurrent objects and systems without having to spend days analyzing "lock" statements. (For any .NET audience, as a 90-minute, half-day or full-day presentation.)

The Busy Java Developer's Guide to Object Serialization
As simplicity-gets-you-power goes, ObjectInputStream and ObjectOutputStream stand as two of the greatest wonders of the Java world. Feed any arbitrary Java object graph to ObjectOutputStream to transform the graph into a stream of bytes, then feed the stream of bytes into ObjectInputStream to transform back into objects again, all without any sort of interference or work on the part of the Java developer. But what if we need to make sure certain fields can't be seen during transmission? Or if we want to optimize the serialized object, for either speed or size? Far more power lies behind the Serialization APIs than just Serializable and transient, and in this session we will examine the customization capabilities of Serialization, allowing you not only to take partial (or complete) control over the serialization process, but even to dynamically-load code from remote locations if the deserializing VM doesn't have the code handy, also known as "mobile objects". (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Remote Method Invocation (RMI)
Remote Method Invocation, or RMI, is at the heart of just about every distributed Java technology, from EJB to Spring to Jini. Learn the "how-to" of RMI, from the basics of "Hello, world" via RMI to the details of exported stubs and how clients can obtain those stubs through more than just the traditional rmiregistry agent. We'll even talk a bit about some of the customization options in the RMI stack, and RMI's nod to CORBA as a transport (RMI-over-IIOP). (For any beginning to intermediate Java audience, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to JAX-Web Services
JAX-WS, formerly known as JAX-RPC, is Sun's specification for doing WSDL-based web services in Java. An examination of what's in the spec, what's not, and a quick look at two implementations: the reference implementation, and Apache Axis. As an added bonus, we'll look at how to interoperate against .NET ASMX, .NET WSE 2, Windows Communication Foundation and Ruby-on-Rails endpoints. (For any Java audience familiar with the basics of the Java language, as a 90-minute presentation.)

The Busy .NET Developer's Guide to Web Services Extensions (WSE)
WCF is Microsoft's new enterprise communications and transactions stack, and represents the "next generation" beyond COM+, ASMX, Enterprise Services, .NET Remoting, and MSMQ. This presentation describes a little bit of the theory (the Four Tenets of Service-Orientation, the Messaging Mandate and the Loosely-Coupled Mantra) and a lot of working code to build services in WCF. Come hear the scope and breadth involved in WCF, the basic architectural model, and why WCF looks to make .NET a solid bet for enterprise systems in the coming decades. (For any .NET audience, as a 90-minute, half-day or full-day session.)

The Busy .NET Developer's Guide to Windows Communication Foundation (WCF)
WCF is Microsoft's new enterprise communications and transactions stack, and represents the "next generation" beyond COM+, ASMX, Enterprise Services, .NET Remoting, and MSMQ. This presentation describes a little bit of the theory (the Four Tenets of Service-Orientation, the Messaging Mandate and the Loosely-Coupled Mantra) and a lot of working code to build services in WCF. Come hear the scope and breadth involved in WCF, the basic architectural model, and why WCF looks to make .NET a solid bet for enterprise systems in the coming decades. (For any .NET audience, as a 90-minute, half-day or full-day session.)

The Busy Java Developer's Guide to Debugging
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. (For any Java audience, as a 90-minute or half-day session.)

The Busy .NET Developer's Guide to Debugging
Debugging .NET applications, particularly those that wander off into native code on a regular basis, can sometimes be awkward on a non-developer's machine (such as the production server). Learn to use the debugging tool Microsoft makes available on almost every operating system it ships, also known as WinDbg, and the .NET extension for it, to inspect, track, and debug your .NET code... without Visual Studio. But if that wenre't enough, we'll examine some of the powerful debugging features inside Visual Studio, as well as various tools Microsoft makes available elsewhere to track down these problems that just won't go away. (For any intermediate .NET audience, as a 90-minute session.)

The Busy Java Developer's Guide to Monitoring
Production? That's where code that behaves itself, follows the rules, doesn't have any nasty evil bugs in it, and "just runs" eventually ends up, right? And once it's there, it's in the hands of the good people, who we call "system administrators", who will do everything it takes to make sure the code never fails. Unfortunately, while that perspective is tempting, it's rarely true, and developers frequently find themselves forced to answer hard questions like, "How many users can we expect per machine?" or "How do we know if it's going to run out of memory in a week or so?" In this presentation, we'll talk about some of the monitoring tools that Java provides to give us--developers and system administrators alike--a look inside the running Java process, like jconsole, jps, jstat and jhat. Then, because monitoring involves much more than just the JVM itself, we'll look into ways to write your own monitorable beans using JMX, and how to write your own, special-purpose monitoring tools using the same technology backplane. Remember: just because code is feature-complete doesn't mean it's ready for Production; find out how to make it so. (For any Java audience, as a 90-minute or half-day session.)

The Busy Java Developer's Guide to Java/Native code
Despite Sun's best efforts, sometimes a Java programmer just has to reach outside the JVM to interact with the underlying platform. For many, this belongs to the intimidating and scary province of "native programming", as exemplified by the Java Native Interface (JNI) API. In this talk, we'll explore JNI and the three ways of using JNI (Java-to-native, native-to-Java, and hosting the JVM through the Invocation API), as well as the recent Java Native API (JNA) library to simplify Java-native access, and the open-source JACE library for easing C++-to-Java interaction. Along the way, we'll talk about how best to protect your Java code against the dreaded "wild pointer" errors from C++, and some of the interesting and powerful effects that Java apps can now hook into using these features. (For any Java audience with some background in C++, as a 90-minute or half-day session.)

The Busy Java Developer's Guide to Hacking (on) the OpenJDK
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; and last but certainly not least, finally we'll build the OpenJDK directly from source code, and maybe tinker just a bit with the source to create a truly "own3d" JVM. Innocents beware--we're a long way from "Hello, Java". (For any advanced audience with a deep background in Java and a casual background or familiarity with C++, as a 90-minute session, half-day tutorial or full-day tutorial.)

The Busy .NET Developer's Guide to the SSCLI (a.k.a. Rotor)