Home    Consulting    Research   Mentoring    Training    Speaking    Writing    About    Contact

 

Neward & Associates is comprised of critically-acclaimed speakers that are Microsoft MVPs, INETA speakers, BEA Technical Directors with a history of speaking at both high-visibility industry events such as TechEd or JavaOne, as well as regional user group meetings. They are constantly involved with the shaping of the industry through organizations such as Java Community Process Expert Groups. Talks are given not just to educate, but with a style intended to entertain and enlighten.

 

 

 

Contact Neward & Associates bring a highly-interactive, entertaining and educational element to your next event; contact us to provide keynotes, tutorials (full- or half-day), or 90-minute presentations on a variety of topics:

 

The Busy Developer's Guide to the New Economy, Free Agency, and (More Than Just) Survival
In 2008, the US economy took the sharpest nose-dive in living memory since the Great Depression. What started out as a localized rainstorm has quickly come to resemble a Category Five hurricane, a figurative "finger of God" storm of destruction that has swept through all industries, markets, and international economies with impunity, imprecision and impartiality. Developers face uncertainty, volatility and insecurity like never before. So why is this presenter smiling? And why does he think you should be, too? (For any audience, recommended as a keynote presentation.)

Iconoclasm
History is littered with the stories of iconoclasts--people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes--and their successes and failures. From the baseball management vision of Branch Hickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly. For an industry that seems so ripe and so rife with "special personalities", it would seem that programming is tied up deeply with iconoclasm. But what defines the iconoclast, what demarcates the "true" iconoclast from the mere pretender, and how can we use the characteristics of the iconoclast to change our own immediate surroundings for the better? (For any audience, recommended as a keynote presentation.)

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.)

Managers are from Mars, Developers are from Venus
You're a manager. You've been hired to run a small (or large) development team, and for the life of you, you can't understand these people. Every time you try to motivate them, they balk and resist. You try to hire them, you can't figure out what they want and they walk away. Then, without any sort of action on your part, suddenly they put in 16-hour days, and they pull off some amazing work, but when you try to ask them to do it again for a critical update, they get angry and quit. What the heck? Where did these bizarre alien creatures come from, and how in the world are you supposed to work with them? (For a non-developer 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: Basics
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. In this presentation, we begin by looking at the Scala type system and flow-control primitives, such as if/else, pattern-matching, tuples, lists, and more. Despite the name, "basics" in Scala can get the newcomer Scala developer quite some distance. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: Objects
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. In this presentation, we focus on the parts of Scala that feel comfortable to the traditional object-oriented developer, and the various ways that Scala improves the object-oriented experience. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: Functions
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. In this presentation, we focus on the parts of Scala are are functional in nature (rather than object-oriented), and study things like currying, partial function application, writing generic functional code, and some of the functional design approaches that can make coding easier. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: Actors
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. In this presentation, we focus on the Actors library in Scala: what it is, how it works, and why it offers a concurrency model that's strikingly easier to understand than the traditional Java "synchronized" approach. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: Scala + Services
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. In this presentation, we take the Scala language, its support for XML, it's immutable and functional approaches, and build a simple XML service with it, no JAX-WS needed (or wanted). Deploying the service as a simple servlet, we show it being consumed from a traditional JAX-WS service client, and from a more "hip" REST approach. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: "Scitter"
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. In this presentation, we take the Scala language, its support for XML, it's immutable and functional approaches, and build a simple XML service client with it, a Twitter client library called "Scitter" (available at scitter.googlecode.com). No prior experience with the Twitter API is required, as we go through and examine some of the "core" Twitter features and describe how the Scala language makes it easy--if not trivial--to access this "RESTful" Web-based API. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a day or half-day tutorial or in two 90-minute presentations.)

Busy Developer's Guide to Scala: Patterns
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. In this presentation, we'll start looking at some of the O-O community's favorite design patterns (from the Gang-of-Four book as well as others) and examine their applicability to Scala, including those patterns that work well here, those that don't, and a few new ones that wouldn't work well anywhere but here. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a day or half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Scala: Thinking
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. In this presentation, we try to graduate "beyond" the syntax by tackling the hardest problem of learning a new language--thinking in that new language. After a brief high-level discussion of some of functional concepts and design ideas/idioms, we'll take a programming challenge, collectively examine how we can implement it in Scala, but instead of just trying to use the O-O approach, we'll try to "think functionally" as well and use all of Scala's features to come up with the most succinct, reusable code we can imagine. It's a deliberately open-ended group-oriented discussion, looking to bring everybody into a different mindset. (For any Java audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other Scala presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy .NET Developer's Guide to F#: Basics
F# is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the CLR as standard assemblies. Sporting the usual object-oriented concepts as classes and inheritance, F# 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 the CLR and .NET class libraries, F# offers .NET programmers an opportunity to write powerful programs with concise syntax for a new decade of .NET programming. In this presentation, we focus on the parts of F# that form the "foundation" of the language, such as its data types, type-inference, and flow control constructs, from basic decision making (if/else) to more advanced constructs like like pattern-matching. (For any .NET audience, as a 90-minute. Strongly recommended in conjunction with the other F# presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy .NET Developer's Guide to F#: Objects
F# is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the CLR as standard assemblies. Sporting the usual object-oriented concepts as classes and inheritance, F# 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 the CLR and .NET class libraries, F# offers .NET programmers an opportunity to write powerful programs with concise syntax for a new decade of .NET programming. In this presentation, we focus on the parts of F# that feel comfortable to the traditional object-oriented developer, and the various ways that F# improves the object-oriented experience. (For any .NET audience, as a 90-minute. Strongly recommended in conjunction with the other F# presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy .NET Developer's Guide to F#: Functions
F# is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the CLR as standard assemblies. Sporting the usual object-oriented concepts as classes and inheritance, F# 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 the CLR and .NET class libraries, F# offers .NET programmers an opportunity to write powerful programs with concise syntax for a new decade of .NET programming. In this presentation, we focus on the parts of F# that are functional in nature (rather than object-oriented), and study things like currying, partial function application, writing generic functional code, and some of the functional design approaches that can make coding easier. (For any .NET audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other F# presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy .NET Developer's Guide to F#: Concurrency
F# is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the CLR as standard assemblies. Sporting the usual object-oriented concepts as classes and inheritance, F# 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 the CLR and .NET class libraries, F# offers .NET programmers an opportunity to write powerful programs with concise syntax for a new decade of .NET programming. In this presentation, we focus on the parts of F# that make it easier/possible to write highly-concurrent applications: asynchronous workflows, message-passing, immutability by default, and more. (For any .NET audience, as a 90-minute, half-day, or full-day presentation. Strongly recommended in conjunction with the other F# presentations as at least a half-day tutorial or in two 90-minute presentations.)

Busy Java Developer's Guide to Functional Java
Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used. In this presentation, we'll go over some basic functional concepts, then start seeing how they apply in the FJ library, and show how to use FJ and functional ideas on common Java programming tasks. Let the excuse "I can only use Java" finally be consigned to the rubbish bin, once and for all. (For any Java audience, as a 90-minute or half-day 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.)

The Busy Java Developer's Guide to Extending Java Apps with Scripting
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.)

The Busy .NET Developer's Guide to Extending .NET Apps with Scripting
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 .NET Developer's Guide to Functional Programming
Functional programming--as implemented by languages like Erlang, Haskell or ML--saw a huge uptick in interest in the latter half of 2007 that has continued to this day. But even if you're not interested in learning a new programming language, we can still derive some powerful new techniques for writing code from functional ideas that will make your C# code that much better. In this presentation, we'll go over some of the basic concepts of functional programming--what it is, why it's different from O-O/imperative programming, and how it changes the programming experience--and see how to use various features of the C# language to make your apps more functional. (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 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 a native/C++ audience using the V8 engine, 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 Design Patterns in 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 start looking at some of the O-O community's favorite design patterns (from the Gang-of-Four book as well as others) and examine their applicability to ECMAScript, including those patterns that work well here, those that don't, and a few new ones that wouldn't work well anywhere but here. (For a native/C++ audience using the V8 engine, 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 .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.)

Busy Developer's Guide to Objective-C 2.0
With the recent resurgence of Apple's hardware platforms and the Mac OS X operating system, developing for the Mac has never been hotter, and Objective-C stands at the heart of that environment. In this presentation, we'll go over the Objective-C language that stands at the heart of Mac and iPhone development, leveraging the experience of the "classic" O-O developer steeped in C++/Java/C# to blow past the parts that are similar to what they're used to, and focus on the parts that are nowhere near the same. By the end of this talk, the C++/Java/C# developer will not only have a good foundation for pressing onwards alone, but also have a basic grasp of how Objective-C and the Mac are different from C++, Java or C#. (For any Java or .NET or C++ audience, as a 90-minute, half-day, or full-day presentation.)

Busy Developer's Guide to Design Patterns in Objective-C 2.0
With the recent resurgence of Apple's hardware platforms and the Mac OS X operating system, developing for the Mac has never been hotter, and Objective-C stands at the heart of that environment. In this presentation, we'll start looking at some of the O-O community's favorite design patterns (both those from the Gang-of-Four book and elsewhere) and examine how they map to the Objective-C language and environment... or not. (For any Java or .NET or C++ audience, as a 90-minute, half-day, or full-day presentation.)

Busy Developer's Guide to iPhone Development
With the recent resurgence of Apple's hardware platforms and the popularity of the iPhone and AppStore as a mobile computing platform and delivery vehicle, developing for the iPhone has suddenly become the "new hotness". In this presentation, we'll go over the basics of iPhone development, from the perspective of developers who've been writing code for other managed platforms (Java, .NET) before. We'll talk about the tools, the languages (Objective-C and Nu), the simulator, and more, and show how to deploy an application to the simulator that comes with XCode, and to the iPhone itself. (For any Java or .NET or C++ audience, as a 90-minute, half-day, or full-day presentation.)

Busy Java/.NET Developer's Guide to Clojure
Clojure is a dynamic functional programming language, targeting the JVM and later ported to the CLR. 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 or .NET applications. (For any Java or .NET audience, as a 90-minute, half-day, or full-day presentation.)

Busy Developer's Guide to Fan
Fan is a powerful object-oriented language that executes on either the JVM or the CLR, utilizing a mix of features drawn from a variety of different programming styles, including dynamic and functional languages. In this presentation ... (For any Java audience, as a 90-minute, half-day, or full-day presentation.)

Busy Developer's Guide to Cobra
Cobra is ... In this presentation ... (For any Java audience, as a 90-minute, half-day, or full-day presentation.)

The Busy .NET Developer's Guide to Microsoft Axum
What happens when you take a general-purpose language like C#, strip it of the various things that programmers do to get themselves into trouble along a particular axis (such as, say, concurrency), then built it back up again with some new concepts that specifically address that same axis? You get a language that's built entirely around the concept of concurrency, and if you're Microsoft, you call it Axum, you make it run on top of the CLR, and you release it to the worldas an experimental project to see if anyone is interested. In this presentation, we'll look at Axum, what it leaves out and what it introduces, and talk about how it can be useful to developers looking for a better concurrency solution than lock(). (For any .NET audience, as a 90-minute, or half-day presentation.)

The Busy .NET Developer's Guide to IronRuby
Looking for ways to extend your .NET programming skills in the dynamic direction without abandoning the platform you've come to love? IronRuby, an open-source implementation of the Ruby programming language on top of the CLR, offers exactly that option: Ruby language and the CLR 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 CLR in this introductory, code-first overview both the Ruby language and the IronRuby implementation. (For any beginning to intermediate .NET audience, as a 90-minute or half-day presentation.)

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.) (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.) (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.) (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 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.)

Busy .NET Developer's Guide to Parallel Extensions for .NET 4.0
With the advent and growing ubiquity of multi-core CPUs, it has become clear: Concurrency is the dragon that programmers must slay in the coming decade, and unfortunately, the current crop of languages in widespread use-the imperative, object-oriented C-family of languages consisting of C++, Java and C#--simply aren't up to the task of handling concurrency easily. Instead, they defer the concurrency responsibilities to the developer, forcing programmers to reason about their code and its throughput and safety on every line. This is an unacceptable solution, and Microsoft has begun work to offer better ones in the next release of .NET 4.0. Nicknamed the "parallel extensions" to .NET, sometimes also referred to as "PLINQ", these extensions offer developers a simpler model for building multi-core-friendly applications, and in this session, we'll spend some time with the parallel extensions, how they work, and where to best utilize them. (For any .NET audience, as a 90-minute presentation.)

Busy .NET Developer's Guide to Retlang
Message-passing coordination/communication systems, as a way of simplifying cross-thread communication, have become all the rage recently, and for some very good reasons. In this presentation, we will explore Retlang, an open-source implementation of a message-passing system in .NET, and how applications can be structured to use it to maximize concurrency and throughput, while minimizing chances for deadlock and starvation. (For any .NET audience, as a 90-minute presentation.)

The Busy .NET Developer's Guide to DSLs in Oslo
Microsoft Oslo is a new system for managing data at all levels of the data lifecycle, from parsing to data storage and manipulation. As a result, Oslo makes for a powerful system for building tools to create parsers for domain-specific languages (DSLs), to transform ordinary text into a graph of objects suitable (in this case) for interpretation or use as an abstract syntax tree (AST) for a code-generative language. In this presentation, we’ll explore the basics of MGrammar, the parser-generator language for Oslo, and how to create a simple DSL parser in less than two hours. (For any .NET audience, as a 90-minute presentation.)

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 Workflow Rules) (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.)

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 .NET 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 Java Collections
For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes. In this presentation, Java developers will see the basic breakdown of the Collection API designs, the relationship of the interfaces to the implementations, how to create a new Collection implementation, and how the new Collections introduced as part of JSR-166 (the concurrency JSR) and Java6 make their programming lives easier. (For an audience comfortable with some prior Java experience, as a 90-minute presentation.)

The Busy Java Developer's Guide to Advanced Collections
Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right? In this presentation, we'll go over what's missing from the Java Collections library, what is provided via other sources (Google and Apache, among others), and what you can provide for yourself, including a brief foray into the world of functional programing, and how it can make your Java code more elegant. (For an audience comfortable with some prior Java experience, as a 90-minute presentation.)

The Busy Java Developer's Guide to Mac OS X
Developing and running Java was supposed to be a "Write Once, Run Anywhere" experience, but.... In this presentation, we'll take a look at how Apple implemented Java on the Mac OS X platform, and talk about how this changes (or doesn't) the Java development experience, with an eye towards the platform-specific things that Java developers may run into. (For an audience comfortable with some prior Java experience, and at least a little experience with the Mac OS, as a 90-minute presentation.)

The Busy Java Developer's Guide to JMS
The Java Message Service API provides a unified programming interface to a variety of different messaging systems, and provides a necessary and important supplement to distributed communications. In this presentation, we'll go over the basics of messaging systems, the core JMS APIs, some configuration tips for popular JMS implementations, and the various message types that can be sent. (For an audience comfortable with some prior Java experience, as a 90-minute presentation.)

The Busy Java Developer's Guide to Advanced JMS
Once you've mastered the basics of JMS, a whole new world of interesting capability opens up. Understanding all of the possible permutative capabilities in the JMS API is another story, however--when do you use transactions? When do you use acknowledgement? When do you use persistent message queues, and when are simpler Topics acceptable instead? Message selectors? In this presentation, we'll go over the JMS API in deeper detail, going over all of the above topics, and giving the Java developer a deeper insight into JMS and how it can make your applications more reliable and interoperable. (For an audience comfortable with some prior Java experience, 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 .NET Developer's Guide to Code Access Security
(For any .NET audience, as a 90-minute presentation.)

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 .NET Developer's Guide to Assemblies
For something so critical to the .NET developer experience, few .NET developers actually spend time studying how .NET assemblies are constructed, found, or loaded into the .NET process space. In this presentation, we crack the lid on the .NET assembly, from its internal layout and format, to how they are found by the CLR at runtime, to when to use the Global Assembly Cache, and so on. We'll talk about how to detect, trap, and correct for when an assembly fails to load, and how to package your code so that it can be found across network connections without resorting to ClickOnce. (For any beginning to intermediate .NET audience, as a 90-minute 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 Concurrency (parts 1 and 2)
From its inception, .NET has included a multithreading/concurrency capability, and baked it in as a core part of the platform. But just because it's there doesn't mean every .NET developer knows how to use it, or when, or why. Worse yet, trying to use it correctly can sometimes fail due to subtle interactions that aren't immediately obvious. In part 1 of this 2-part presentation, we go over the core .NET threading model, the thread pool, how it builds on top of the underlying operating system, and some of the useful abstractions the .NET environment provides on top of the multithreaded environment. Then, in part 2, we explore the .NET monitor system of synchronization, and how that provides atomic access. We go over some of the strengths and weaknesses of this approach, then explore some of the other synchronization mechanisms provided in the System.Threading namespace. (For any beginning to intermediate .NET audience, as a 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 .NET Developer's Guide to MSMQ
(For any .NET audience, as a 90-minute presentation.)

The Busy .NET Developer's Guide to the Concurrency and Coordination Runtime
The Microsoft Concurrency and Coordination Runtime, a.k.a. the CCR, originally debuted as part of the Microsoft Robotics Studio. But developers quickly discovered that concurrency and coordination is something that non-robotics developers also need to wrestle with, and as a result, the CCR has begun to see some adoption by enterprise software apps and environments. In this presentation, we'll talk about the CCR, how it works, and how you can use it in your own code to get out of the "Now, how many threads could possibly execute this line of code?" analysis game. (For any .NET audience, as a 90-minute 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 .NET Developer's Guide to Object Serialization
(For any .NET audience, as a 90-minute 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
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. 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 Java Developer's Guide to Hacking (on) the OpenJDK
With the release of the OpenJDK source code, Java developers have been given a unique opportunity to peer inside the hood of the JVM, see what's there, and how Java code actually executes. In this presentation, we'll talk about how to get the OpenJDK codebase, how to compile it (for both Windows and Linux systems), and point out some of the more interesting aspects of the JDK source base. Developers will walk away with a deeper appreciation for exactly what happens when they run Java code. Innocents beware--we're a long way from "Hello, Java" with this one. (For any advanced Java audience with a deep backgroundin Java and a casual background or familiarity with C++, as a 90-minute or half-day presentation.)

The Busy .NET Developer's Guide to the SSCLI (a.k.a. Rotor)
The Shared Source Common Language Infrastructure (the SSCLI, also known as Rotor) offers .NET developers a unique view "inside" an implementation of a Common Language Infrastructure runtime--in short, an insider's view of .NET. Find out how to use Rotor to gain useful insights into your .NET code, from one of the guys who wrote the book on it. (For an audience familiar with .NET and unafraid of C++, as a 90-minute, half-day or full-day presentation.)

The Busy Developer's Guide to db4o
The object/relational impedance mismatch, the heart of the difficulty in pushing objects to relational databases and back again, has been a barrier to effective object-oriented development for well over a decade now. While tools like Hibernate, JDO, and even code-generation have sought to evade this mismatch by providing automated translation of objects to relational tuples and back again, they only offer partial solutions, many of which are less than optimal at some level. Is it time to reconsider? db4o, an object persistence library that eschews the relational database entirely, is an downloadable implementation for both Java and .NET that stores objects natively--no translation to SQL whatsoever--making true "object persistence" once again a reality. In this presentation, we'll take a code-first exploration of this library, its query syntax and API, and discuss some of the pros and cons of using it in various applications and environments. (For any Java or .NET audience, as a 90-minute or half-day session. Please specify your audience's background or preference when scheduling.)

A Busy (Java/.NET/C++) Developer's Guide to XSLT
XSLT (or, more properly known as XSL:T, short for eXtensible Stylesheet Language: Transformation) is a powerful tool and language for taking XML source data and, as the name implies, transforming it into a variety of different results--HTML, other XML, plain text, comma-separated-value files, and more. This presentation offers a code-first introduction of the XSLT langauge: the constructs, the different "styles" of XSLT, and even, the various mechanisms by which XSLT engines can be extended by host platforms (C++, COM, Java or .NET). No prior experience with XSLT or XPath is necessary, though basic understanding of XML is helpful. (For any audience, as a 90-minute or half-day session.)

A Busy (Java/.NET) Developer's Guide to XML Schema Description (XSD)
XML Schema (also known as XSD) provides a powerful tool for providing metadata regarding the structure of an XML document. From that, the industry has developed a number of useful tools to save the working programmer a good amount of time, by offering automated validation of incoming XML documents against a schema, to providing object-XML bindings to simplify the generation and parsing of XML. But XSD itself is a large, and potentially complex specification, with a lot of nuances and quirks, making XSD seem unapproachable and mysterious. In this presentation, we take a code-first approach, working from the simple to the complex, describing the core elements of XSD, why to use them, and when to use them. (For any intermediate audience, as a 90-minute, half-day or full-day presentation. Ask about tuning it specifically to your Java or .NET audience, particularly by combining it with the "Busy Developer's Guide to XML Binding" talk, below.)

A Busy (Java/.NET) Developer's Guide to XML Binding (Using XmlSerializer) (Using JAXB) (Using XMLBeans)
It's true that XML has become the standard representation for "portable data" across platforms and languages, but that doesn't mean it's always easy. Many developers find the process of generating XML documents by hand to be tedious and error-prone. Many also find the process of consuming (parsing) XML documents to be even worse, wading through callbacks and events, or navigating through node after node after node to find the data of interest. In this presentation, we look at toolkits designed to simplify that process (the XmlSerializer in .NET, the JAXB, or XMLBeans toolkits in Java) by creating automated mappings of object-to-XML transformation in both directions. (For any audience at least casually familiar with XML; this can be delivered in one of four ways, using XmlSerializer for the .NET audience, or using one of JAXB or XMLBeans for the Java audience, as a 90-minute presentation. For Java audiences, multiple toolkits can be combined into a half-day or full-day presentation.)

A Tour of Microsoft Research
Microsoft Research (MSR) is a group of smart folks dedicated to building interesting tools and libraries. In this talk, we'll tour some of those tools and libraries, look at some of the "more interesting" ones, and discuss how MSR's efforts can be used to make your life--as a practicing programmer--a lot easier. Tools we'll discuss will include Fugue (a powerful tool for specifying and enforcing resource and state-machine protocol specifications), Detours (a library to make it easier to "hook" calls made to DLLs), Joins (a new concurrency library based on the research from C-Omega), AbsIL (a library to make it easier to manipulate compiled .NET assemblies), and more. (For any .NET audience, as a 90-minute, half-day or full-day presentation.)

A Tour of IBM Alphaworks
IBM's Alphaworks website is a place where many of IBM's smartest folks hang out and release, for general consumption, interesting tools and libraries. In this talk, we'll tour some of these tools and libraries, look at some of the "more interesting" ones, and discuss how Alphaworks' efforts can be used to make your life--as a practicing programmer--a lot easier. Tools we'll discuss include XJ (a new language variant of Java that includes XML literals), CFParse (a bytecode manipulation toolkit that includes a bytecode disassembler), CodeRuler (a Java instructional tool disguised as a multiplayer game) and more. (For any Java audience, as a 90-minute, half-day, or full-day presentation.)

A Tour of the Open Source Java Community
If you're like most developers, you know about the "big names" in the open-source community, like Ant, Tomcat, Spring and Hibernate, but beyond that, you may be feeling a bit overwhelmed at trying to keep up with all the projects out there and their status. This presentation highlights some of the most interesting projects in the open-source community (at least, according to the presenter's opinion), what they're useful for, and a brief primer on how to use them. (For any Java audience, as a 90-minute, half-day or full-day presentation.)

A Tour of the Open Source .NET Community
If you're a .NET developer, the whole concept of "open-source" tools and technologies may be coming out of left field to you. Certainly some of them you may have heard of before--NUnit, NAnt, NDoc, and so on--but what else is out there that might save you a bit... or a lot... of time? This presentation takes a quick lap around the more interesting (in the presenter's opinion, anyway) .NET open-source tools, technologies and frameworks, and describes them, what they're useful for, and a brief primer on how to use them. (For any .NET audience, as a 90-minute, half-day or full-day presentation.)

The Busy .NET Developer's Guide to Building a Profiler/Debugger
The Common Language Runtime has an incredibly powerful mechanism "under the hood" by which developers can track object allocation, class definitions, AppDomain creation and destruction and more, and it goes by the name of the .NET Debugger and Profiler APIs. This presentation will give an overview of how to build a .NET Debugger/Profiler, what kind of power is available to you in doing so, and why you might look to build your own, when so many commercial debuggers and profilers are already available. (For audiences familiar with the .NET platform and comfortable writing/understanding unmanaged C++, as a 90-minute session.)

The Busy Java Developer's Guide to Java5
Java5 introduced a whole slew of new features, including annotations (JSR 175), new language features (the enhanced for loop, enums, annotations, generics, static imports, and more), new library support (JMX and java.lang.instrument, among others), and some interesting enhancements to the virtual machine itself. This presentation will go over those features, explain why they matter, and how you can take advantage of them in a variety of different practical ways. (For an audience comfortable with some previous version of Java, as a 90-minute or half-day presentation.)

The Busy Java Developer's Guide to Java6
In this presentation, we'll go over the major new features of the Java6 platform, including the new integrated XML services capabilities (JAX-WS and JAXB), dynamic/scripting language support (javax.script), new JVM "attach" capabilities, new annotations supported by the javac compiler, and more. (For an audience comfortable with some prior Java experience, as a 90-minute presentation.)

The Busy Java Developer's Guide to Java7
Even though the Java 7 JSR has yet to be formed, some interesting things are beginning to emerge from Sun about what Java7 may include when its formal release contents are finally made public. In this presentation, we'll examine some of the forthcoming details, including some of the JSR-166 "add-ons" like the Fork/Join framework, some of the proposals for extensions to the JVM to support dynamic languages, and the so-called "closures" proposals circulating around. (For an audience comfortable with some prior Java experience, as a 90-minute presentation.)

The Busy .NET Developer's Guide to Phoenix
With the alpha release of the Phoenix Research Development Kit, Microsoft has released a powerful tool for any developer interested in taking charge slicing, dicing, exploring or modifying managed or unmanaged code. Phoenix can provide the "back half" of a compiler, providing powerful code-generation techniques for a programming language, or extensive static analysis tools of compiled code, even allow developers to take charnge of JIT compilation inside the CLR. Find out what Phoenix can do for you. (For any advanced audience, as a 90-minute presentation. Ask about the possibility of delivering it as a half-day or full-day tutorial.)

What Every Hard-core O-O Developer Should Know About Visual Basic
Visual Basic and object-orientation... for so long, the Visual Basic language has been the laughingstock of the object-oriented purist, only recently gaining all of the features that for so long have dominated the object-oriented mindspace: implementation inheritance, dynamic method dispatch, and so on. Now, however, with the rise of interest in "dynamic" languages like Ruby and Python, it's time to go back to good ol' VB, and find out what was there all along.

The Open Web Application Security Project Top Ten List (and Why You Should Care)
The OWASP Top Ten List has itemized the top ten web application security vulnerabilities for four years now. It's a useful primer and short list of things to be worried about when conducting a security review of your own applications, particularly since the emphasis in security has shifted from infrastructural concerns (like TCP/IP-based attacks) to application-leve lones. This presentation will cover each vulnerability, why it's a concern, and how best to avoid them in your code in current and future projects. (For any intermediate audience, as a 90-minute, half-day or full-day presentation. Ask about tuning it specifically to your Java, .NET or C++ audience.)

The Fallacies of Enterprise Development
Every enterprise developer, at some point in their career, has fallen into the trap of 10 devilishly subtle enterprise software development assumptions. Come hear what they are, why they all lead to big trouble and painful learning experiences in the long run, and how to avoid them using the tools and technologies of your favorite platform. (For any intermediate audience, recommended as a half-day tutorial.)

Core WCF Patterns
There's a whole other enterprise development world out there, and they've been building enterprise systems for close to a decade now. As a result, the Java community has long had a collection of patterns by which to be guided when building enterprise systems, one of the most popular of which is Crupi, Alur and Malks' "Core J2EE Patterns". In this talk, we'll examine some of the popular J2EE enterprise design patterns, discover what the problem, context and consequences were for each, and discuss how they might relate to the world of Windows Communication Foundation and .NET. (For any .NET audience, as a 90-minute or half-day session.)

SOAP for the masses
There's been a lot of discussion around the various XML services technologies, but in a lot of ways it all essentially keys off of one specification in particular: SOAP. What is the SOAP 1.2 specification, why does it exist, and what does it mean to developers looking to begin working with XML services in general? And do SOAP endpoints really have to be written using JAXWS, EJB, ASMX or WCF? (For any intermediate audience with a background in the XML stack of your favorite platform, as a 90-minute session.)

Extending System.Xml
XML is a great way to respresent hierarchical data in a structured format, easily consumed by a variety of languages and platforms, and .NET provides a powerful stack for consuming XML data in the System.Xml libraries. But "consuming" XML has deeper requirements than just "parsing" XML, and Microsoft has done a number of things to make it easier for the .NET programmer to reach into XML data and extend it in new and interesting ways. In this talk, we'll examine the various mechanisms Microsoft has made available to hook parts of the classes provided by System.Xml, including the changes made in WinFX 2.0, and why this creates greater opportunity for .NET programmers to work well with XML. (For any .NET audience, as a 90-minute presentation.)

Strongly-typed Infosets in .NET
A large part of processing XML is pulling data in from the XML representation (the Infoset) and putting it into your object domain model; not only is this largely tedious, but when the XML changes, you need to change your object model to reflect it even if you don't use it, or the data is lost. Find out how to combine the Infoset model and your object model into a single entity in .NET, and why this can be orders of magnitude more flexible than the traditional XSD-based code-generation approach. (For any intermediate .NET audience, as a 90-minute session.)

Strongly-typed Infosets in Java
A large part of processing XML is pulling data in from the XML representation (the Infoset) and putting it into your object domain model; not only is this largely tedious, but when the XML changes, you need to change your object model to reflect it even if you don't use it, or the data is lost. Find out how to combine the Infoset model and your object model into a single entity in Java, using either JDOM or BEA's latest open-source offering, XMLBeans, and why this can be orders of magnitude more flexible than the traditional XSD-based code-generation option. (For any intermediate Java audience, as a 90-minute presentation.)

XML Messaging in Java
SAAJ is Sun's specification for doing SOAP messaging. This presentation includes an examination of what's in the spec, what's not, and a quick look at the reference implementation, and how you might simply roll your own rather than rely on a vendor implementation. For comparison's sake, we then discuss ActiveSOAP, another XML messaging software stack from the open-source community, and discuss the pros and cons of each. (For any Java audience familiar with the basics of the Java language and XML, as a 90-minute or half-day presentation.)

XML Messaging in .NET, using Web Services Enhancements 2.0
WSE 2 is Microsoft's last WSE release for the .NET 1.x platform, and provides a "messaging pipeline" for exchanging XML data with other endpoints over a variety of transport channels. This presentation provides an examination of the WSE 2 programming model, how it layers on top of ASMX, how it can be used outside of HTTP, and how it interoperates with other platforms, including Java. (For any .NET audience still on the .NET 2003 platform, as a 90-minute or half-day presentation.)

XML Messaging in .NET, using Windows Communication Foundation
WCF is Microsoft's future technology base for all program-to-program communication, and while it provides a convenient RPC-like model, some of the real power behind WCF lies in its messaging-based pipeline under the covers. This presentation "lifts the hood" on the RPC facade, looks at how to use WCF in a messaging-based fashion, and how it can be tuned to interoperate easily with legacy .NET endpoints, Java endpoints, and even REST-based endpoints. (For any .NET audience on the .NET 2005 plaform, as a 90-minute or half-day presentation.)

The JVM and the CLR: A comparison of two runtimes
Java and .NET are clearly the two leading candidates for any new enterprise application or system. In this talk, we'll examine the underlying execution environment for both platforms (the JVM and the CLR), and what sort of similarities--and differences--exist between them that yield insights about both in general. (For any audience, as a 90-minute presentation.)

Hosting the HttpRuntime
Part of the excitement of .NET is ASP.NET, also called the HttpRuntime. What few developers realize is that ASP.NET is entirely divorced from IIS, and is written entirely in managed code (C#). What this means is that you can use ASP.NET web services functionality (like .asmx and .ashx files), without having IIS installed on the box. It also means you can use the HttpRuntime in ways far beyond "just" serving up dynamically-generated HTML; find out how to host it, when to host it, and why you might want to host it in the first place. (For any .NET audience, as a 90-minute presentation.)

Intro to the WS-* Stack
XML services is a complicated subject, complete with several false starts and specification mistakes. In this talk, we'll look at the specifications that make up XML services, why they are there, and what they do. In addition, we'll look at the parts that have been deprecated, the parts that have changed, and why the shifts in focus. Those who attend this talk will not only have a good idea what XML services are, but why they look the way they do and what it would take to implement a XML services endpoint in a fashion that will stand the test of time. (For any audience, as a 90-minute presentation or half-day tutorial.)

Don't see something you like? Ask!
We can also deliver just about any of our training materials as a 90-minute, half-day or full-day presentation, either as a lecture-only presentation or as a hands-on tutorial--just ask!

 

 

     Upcoming Events

 

<< past events

 

 

home  |  about  |  consulting  |  speaking  |  mentoring  |  research  |  writing  |  contact

 

Copyright © 2006 Neward & Associates. All rights reserved.