Dave Thomas comes to Atlanta - Next Tuesday - Sept 16th

["Burr Sutter" <sutter@bravepoint.com>]

Date: September 16, 2003
Start Time: 6:30 pm for general discussion and networking
Presentation:  7:00 to 9:00 pm
Place: Holiday Inn Select - 4386 Chamblee Dunwoody Rd, Atlanta, GA  30341
(770) 457-6363
Exit 30 - one exit east of Ashford-Dunwoody off 285.

Description:
Decoupling Patterns -- untangling that knot of code by Dave Thomas We all
know what highly coupled code feels like: make a minor change over here, and
suddenly things start acting funny over there, and over there, and... So how
do we avoid this? It turns out that following a few basic rules can stop
this mess from happening. See how "The Jolly Good Suggestion of Demeter" and
Pina Colada mixing (among other topics) will help you write better software.


Speaker Bio:
Dave Thomas is recognized internationally as an expert who develops
high-quality software--accurate and highly flexible systems. He helped write
the now-famous Agile Manifesto, and regularly speak on new ways of producing
software. He is the author of two books, including the best selling The
Pragmatic Programmer: From Journeyman to Master (Addison-Wesley) and
Programming Ruby: A Pragmatic Programmer's Guide (Addison-Wesley).

As always we like to thank our sponsors that provide resources for our
meeting facilities, A/V equipment and website hosting: BEA (www.bea.com),
BravePoint (www.bravepoint.com), Inflow (www.inflow.com), Spectrum Software
(www.spectrumscm.com) and Compuware (www.compuware.com).

Atlanta Java Software Symposium 2003

When:       October 24-26, 2003
Where:      Hyatt Regency, Marietta

Don't miss your chance to choose from over fifty education and solution
based sessions (see below for details) at the Atlanta Java Software
Symposium 2003.  You have the opportunity to attend one of the best Java &
related technology conferences offered and it is right here in Atlanta. Our
session schedule is listed below for your perusal.

Limited Attendance (200)
Nationally Recognized Speakers
In-depth Discussions
Peer Exchange
Unparalleled Access to Speakers
Expert Panel Discussions
Hands-on Code Examples
Best Practices
Insight on Cutting-Edge Tools
No Product Demonstrations

For more information and registration details,
http://www.nofluffjuststuff.com/2003-10-atlanta/index.jsp or
contact Jay Zimmerman, AJSS Symposium Director at
jzimmerman@nofluffjuststuff.com.

The early bird registration for AJSS 2003 is $595/person.  For AJUG members,
we have an additional $50 off discount thru 9/26/03.  Use the discount code,
"ajug545" when registering online.

The registration fee includes:
- Admission to the symposium
- CD with all presentational content
- Handouts for each session attended
- Meals & snacks

We have some great development team discounts:

5-9 Attendees:         $ 545/person
10-14 Attendees:      $ 495/person
15-24 Attendees:      $ 450/person
25-over Attendees:    $ 400/person

Atlanta Java Software Symposium 2003

-Session Listing-
JDO and Transparent Persistence by Dion Almaer
Many developers are demanding transparent persistence. Java Data Objects
(JDO) is aiming at standardizing this need in the JCP.  This talk shows you
what JDO is, how it fits in with J2EE technology, and some of the politics
behind it.

WebWork - Strutting the OpenSymphony way by Dion Almaer
WebWork is one of the larger MVC frameworks for J2EE. This talk looks at
some of the features that make this framework unique - such as it's command
driven nature, it's ability to participate in a test driven development
environment, the interceptors and AOP features and the new inversion of
control based components. It'll also touch on the highly religious Struts vs
WebWork debate.

Faces - A new face of web app development by Dion Almaer
Abstract: JavaServer Faces gives us a standard server-side component
framework.  This talk looks at the ins and outs of this new way of doing web
app development.

Enterprise AOP with AspectJ by Ron Bodkins
This session builds on the core concepts of Aspect Oriented Programming
(AOP) by demonstrating its use for enterprise Java development. AOP has
become a major topic in the future of enterprise Java development. We
provide a conceptual road map, tangible examples of how AOP works and can be
beneficial, as well as discussing anti-patterns (how not to use AOP).

The presentation illustrates uses of AOP with examples ranging from
development support via standards enforcement and profiling, through
auxiliary areas such as timing and systems management to core design topics
like persistence and business aspects. It demonstrates techniques for using
AOP with major J2EE technologies (i.e., servlets, JSPs,, EJBs) and adjunct
technologies such as Struts. The tutorial primarily uses AspectJ (the
leading AOP implementation).  At the end of the talk, participants should
have an understanding of both the potential and the pitfalls for applying
AOP for enterprise Javat. The tools used in the tutorial are all freely
available via open source so participants can apply the techniques shown in
their own projects. AspectJ is available at http://eclipse.org/aspectj.

Application Security Integration by Ron Bodkins
One of the core values of Java has always been a secure platform. In past,
many projects used J2EE security with application server-specific
extensions. The JAAS approach to application security promises to make a
major change to this model, as does BEA's new Weblogic 8.1 Security
Framework.

Most projects need to integrate application security with third party
products such as databases, message queues, and single sign on servers. And
the recent flurry of XML and Web services activities has produced several
important new security standards: XML Digital Signature, XML Encryption,
SAML, XACML, and the WS-Security draft. Aspect-Oriented Programming also
promises to greatly improve consistency and flexibility in security
integration, while also raising some security questions.

This presentation explains these current and emerging trends in application
security. It outlines the technologies, assesses whether and for what they
are important, what approaches there are to integrating them, and what the
trade offs are for each. It addresses these topics by mapping them into
common technology "stacks" and into uses cases such as access control,
recording audit trails, tracking user identity between tiers and systems,
customizing UI displays to only show, and (links to) authorized items.

Testing with Virtual Mock Objects by Ron Bodkins
More and more projects have become "test infected" and realize the
importance of effective unit and integration testing for improving quality
and to enable refactoring to keep code clean . Testing harnesses such as
JUnit have proven very helpful. However, there many components are not
easily tested. Too many tests require complex set up, extensive interface
changes to introduce "mock objects", produce results that are difficult to
interpret, and require too much drugery to implement.

This session provides an overview of JUnit and mock objects. It also
demonstrates a new way of writing JUnit test cases that uses AOP to write
"virtual mock objects." These simplify the isolation of tested classes from
others, allow easy introduction of stubs in a context sensitive manner
without compromising the original design, and facilitate thorough analysis
of test results.

Effective Object Orientation by James Duncan Davidson
Object Oriented Programming is a WonderLand of sorts: The rabbit hole is
very much deeper than it looks and its easy to get lost in the details.
Fortunately, the history of OOP, including the original Smalltalk language,
provides many solutions to problems that continue to be encountered today.
This presentation explores some important Object Oriented techniques,
inspired by some of the lessor-known Object Oriented languages, in a way
that can be applied to currently used systems.

Mac OS X Overview by James Duncan Davidson
Mac OS X has rapidly been adopted by people that are not traditional Mac
users: Unix developers, Open Source hackers, and Java developers. This
session will bypass the marketing gloss and explore the reasons why the
speaker turned off his Solaris, Linux, and Windows machines in favor of a
PowerBook for programming, setting up mail and web servers, and most of his
other computing tasks. This presentation explores a set of technologies
including the solid and reliable BSD Unix foundation, the beautiful and
capable Quartz and Aqua, the powerful Cocoa framework, Bluetooth, and
Rendezvous.

Effective Collaboration by James Duncan Davidson
Whether you are working in a small team of just a few people, or are part of
a globally dispersed organization developing complex system software, there
are a set of tools that will help you collaborate with your peers better and
help you produce better software. No matter which methodology you use, tools
like version control and issue tracking can make or break your project. In
addition, there are many other tools such as Blogs and Wikis that can change
the way you develop software. This session will focus on when and how to use
different kinds of tools to improve collaboration in your organization, and
recommendations (many of them Open Source) on what to use.
Objective-C Essentials by James Duncan Davidson
Objective-C is a relatively simple object-oriented language inspired by
Smalltalk and designed to enable sophisticated object-oriented programming
without sacrificing performance, access to system level functionality, and
integration with legacy code. Used as the primary language of Mac OS X's
Cocoa framework (the modern successor of the well-known and respected
NeXTSTEP), Objective-C has much to teach all object-oriented programmers.
This presentation explores the design center of Objective-C, introduce you
to its usage, and showcase its unique capabilities.

Managing WSDL with AXIS by Stuart Halloway
The Web Services Description Language (WSDL) can be a hostile environment,
especially if you are used to more Java-friendly remoting technologies such
as RMI. But WSDL is the backbone of Web Services as they exist today, so you
have to find a way to approach it.  Apache AXIS provides tools for managing
WSDL. WSDL2Java builds Java interfaces, implementations, and even test cases
from a WSDL document. More interestingly, Java2WSDL can generate WSDL from
your existing Java classes. Unfortunately, starting from Java will not
always guarantee interoperable Web services. Sooner or later, WSDL must take
top billing.  However, starting from Java and experimenting with Java2WSDL's
settings is a gentle way to introduce WSDL, without having to assemble an
entire WSDL document from scratch.  In this session, we will start from a
Java class, and experiment with Java2WSDL's configuration settings. For each
option, we will discuss real-world scenarios where that option might be
used, and its implications for interoperability with other leading web
service implementations. We will also note where AXIS is implementing a
standard such as JAXRPC, and where AXIS goes beyond the standards.

JCA & JCE by Stuart Halloway
The Java Cryptography Architecture (JCA) and Java Cryptography Extension
(JCE) provide a complete, flexible, and extensible solution to most
cryptography needs. This talk covers JCA and JCE in three parts:  1).  JCA
and JCE are complete -We start at the beginning, with the basic crypto
operations, including encryption, hashing, message integrity, digital
signatures, and key management. You will see what these operations do, why
you need them, and how JCA and JCE implement each.  2). JCA and JCE are
flexible -JCA and JCA are built around a provider mechanism, which allows
flexibility in choosing algorithms and implementations from multiple
vendors. You will see how to configure the virtual machine to select
different providers, and how to programmatically select a provider at
runtime.  3). JCA and JCE are extensible -The provider mechanism also allows
you to develop your own providers. You will see how to write your own custom
provider and integrate it into a standard Java runtime environment.

Learning Tests by Stuart Halloway
This talk will teach you to use unit testing for learning and validating
other people's code. You can use learning tests to teach yourself how to use
a new API, and simultaneously validate that the API meets your needs.
Learning tests is very similar to test-driven development. With TDD, you
write tests that fail, then develop your code to make the tests pass. With
learning tests, you learn a new API by writing tests that prove the API
works. No more wading through erroneous JavaDocs!  What could be more fun?
In a short 90 minutes, you will learn a new Java API, learn JUnit, and learn
a new approach to learning Java.

Class Loading by Stuart Halloway
Java's class loader architecture provides a dynamic and extensible mechanism
for building applications. You will learn how to use class loaders to deploy
multiple versions of classes side-by-side in the same JVM, and how to
redeploy components withtout shutting down servers. You will also learn how
to troubleshoot class loading problems such as inversion. You will learn to
use the context class loader to correctly implement factory methods, and how
to load non-code resources.

You will also see the problems that J2EE and other container environments
pose to the standard class loading architecture. You will see that the
"solutions" to these problems (the endorsed standards override mechanism and
non-delegating class loaders) cause as many problems as they solve, and
learn to work around the wrinkles that these non-solutions introduce

XML Schema for Java programmers by Stuart Halloway
XML Schema, despite its verbose syntax, offers some concepts that are
familiar to Java programmers, e.g. types and inheritance. Don't let the
similarities lull you into a false sense of familiarity. XML Schema is a
rich typing mechanism that is more complex that the Java type system.   This
talk will explore Schema, emphasizing concepts such as derivation by
restriction that are alien to Java developers. You will also see how XML
Schema compares to other schema languages for XML, how to use schema
validation in applications, and how to translate between schema types and
Java types. This is a 3 hour session with a 15 minute break.

Introduction to Lucene by Erik Hatcher
How would you like a mini-Google embedded in your Java application? Lucene
is just the thing for embedding sophisticated, highly scalable, and
incredibly fast searching into your application. This session introduces
Lucene, including what it is not. Lucene is only an API, so it requires
development. The development time to be up and running with Lucene is
minimal, and its API is relatively simple - after this session you will have
the code and knowledge to immediately build your own custom search engine.

Ant Primer by Erik Hatcher
As the de facto standard build tool, all Java developers should have a
working knowledge of its capabilities, syntax, and best practices.  This
session gently introduces you to Ant.  A complete Java project will be
developed interactively, leaving you with the ability to be immediately
effective at using Ant for your next project!

Applied Ant by Erik Hatcher
There is a lot more to Ant than just understanding its syntax and
capabilities.  This session covers using Ant with the following
technologies: EJB, XML, web services, and web applications. Techniques for
unit testing and continuous integration are covered. And finally, many of
the discussed techniques will be showcased interactively.  Note: this
session assumes you have attended the "Ant Primer" session, or are already
familiar with Ant's basics.

Introduction to XDoclet by Erik Hatcher
If you are developing J2EE applications, you need to be using XDoclet.  This
powerful tool not only saves time and unnecessary duplication, but can also
reduce hard-to-find errors.  This session explains what XDoclet is, why it
was created, and how to use it for J2EE development.  Specifically, XDoclet
generates web, EJB, tag library, and vendor-specific XML deployment
descriptors as well as EJB Java interfaces, and these aspects are covered in
this session using interactive live demonstrations.

eXtreme XDoclet by Erik Hatcher
An out-of-the-box installation of XDoclet will work wonders, but there can
be a need for more than the basics.  For example, rather than accepting the
basic EJB lookup utility helper class, a custom template can be provided to
generate a more sophisticated "proxy" object decoupling the presentation
tier from direct EJB access and allowing statistics to be gathered for each
method invocation.  Providing a custom template for existing XDoclet
functionality is just the beginning, though.  Generating custom text files
(XML, properties, Java source code, etc) based on any information nested
within source code can save hours, days, or more in a projects lifetime.
This session details XDoclet's templating language, how to extend it with
custom tag handlers, and even how to write custom subtasks to control the
processing in sophisticated ways.  Erik used XDoclet to generate the Ant
task reference for his book, Java Development with Ant, which required the
use of all of these advanced techniques to process Ant's own source code to
distill its valuable information

Scripting on the JVM by Joey Gibson
Many popular scripting (or dynamic) languages, such as Ruby, Python and
Scheme are now available running on top of the Java virtual machine. These
languages offer many exciting possibilities when run this way, including
easy prototyping of Java programs, creation of utility programs to interact
with existing Java programs, interactive execution of Java code and,
typically, the ability to embed the interpreter in a Java program to provide
users with a customization engine.

These languages, due to their dynamic nature, dispense with the
edit-compile-run cycle. Couple this with the interactive mode that most of
these languages support and you have a powerful combination. In this session
we will spend some time discussing the various languages that are available
on the JVM, specifically Python and Ruby, in general; in other words, the
basics of each language, outside the JVM. We will then dive in to the
specifics of using the Java-enabled versions, Jython and JRuby. We will see
examples of interactive sessions, custom programs and how to embed them. We
will also touch on some of the other available languages like Rhino
(JavaScript) and some of the less well known languages like JudoScript.

JSR 175: Custom Metadata for Java by Ted Neward
One of the most important JSRs in the JDK 1.5 release (and, arguably, in
Java's history) is the Metadata specification, JSR 175, which will permit
Java library developers to define "attributes", bits of Java code that can
be annotated to just about any part of the Java programming model--classes,
packages, methods, fields, and so on. In this talk, hear what the JSR
covers--and what it doesn't cover--along with syntax and usage model from
one of the members of the Expert Group working to define it.

EEJ: Architecture by Ted Neward
In the style of works of the same title, "Effective Enterprise Java" lays
out a number of items that offer practical, far-reaching advice about how to
build systems using J2EE. In this talk, we will go over a number of the
items in the "Architecture" chapter, focusing on higher-level discussions
like "Avoid round trips", "Understand what middleware actually does", and
"Optimize optimally". Discussion will center on what each of these means in
practical terms for the J2EE community, and why current systems don't do
this already.

Effective Enterprise Java - Systems by Ted Neward
In the style of works of the same title, "Effective Enterprise Java" lays
out a number of items that offer practical, far-reaching advice about how to
build systems using J2EE. In this talk, we will go over a number of the
items in the "System" chapter, focusing on items that center around the JVM
itself and its platform infrastructure. Items like "Use the right JVM", "Use
independent JREs for side-by-side versioning" and "Recognize ClassLoader
boundaries" will give attendees the necessary tools to start improving their
J2EE applications without ever having to change a line of code.

Effective Enterprise Java: Concurrency by Ted Neward