Early Bird Registration expires 9/26/03 for the Atlanta Java Software Symposuim 2003

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

Atlanta Java Software Symposium 2003
October 24-26, 2003
A "No Fluff, Just Stuff" Conference
www.nofluffjuststuff.com

The No Fluff Just Stuff Java Symposium Tour cordially invites you to
register for the Atlanta Java Software Symposium. This three day Java
conference will be offered in Atlanta, GA on October 24-26, 2003.  AJSS 2003
is designed for Java developers, Java Architects, and technical managers who
are looking for further insights on the J2EE, XML, Web Services, Best
Practices and Open Source.  Please see the session agenda below for a
detailed look at the presentations offered at AJSS 2003.

The Atlanta Java Software Symposium will feature over forty high quality
technical presentations and an expert panel discussion and
point/counterpoint sessions.  In addition, some of the speakers are:

. Ted Neward, author of the soon to be released "Effective Enterprise Java"
. Bruce Tate, author of the best seller, "Bitter Java" and "Bitter EJB"
. Stuart Halloway, author of "Component Development for the Java Platform"
. James Duncan Davidson, creator of Apache Tomcat/Apache ANT
. Erik Hatcher, co-author of "Java Development with Ant"
. Dave Thomas, author of "The Pragmatic Programmer"
. Sue Spielman, author of "The Struts Framework: A Practical Guide for Java
Programmers"
. Dion Almaer, TheServerside.com Architect

The Top 5 Reasons to attend the Atlanta Java Software Symposium:

1). AJSS 2003 has a limited attendance of 200 people.  We do this to
insure a great deal of interaction between speakers and attendees.
2). AJSS 2003 presentations are content rich.  You will come away with
new insights/knowledge that you can immediately apply in your development
environment.
3). High quality speakers who have tremendous technical depth, practical
experience and the requisite knowledge transfer skills to be an excellent
speaker.
4). The best value in terms of dollars/time ratio of any Java based
conference currently offered.
5). The format of AJSS 2003 allows companies to send entire software
development teams because of price, location and timing (held over a long
weekend).

Registration/Pricing Information:

The early bird registration for AJSS 2003 is $595/attendee thru 9/29/03.
There is a special discount of $50 available to all AJUG members valid thru
9/26/03.  Please use the discount code "ajug545".   After 9/29/03, the
registration fee will be $695/person.

The registration fee includes admission to the symposium, symposium CD with
all presentation content, handouts for each session attended and all
meals/snacks.


There are excellent discounts available for software development teams:

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

Want to Know More? Questions?
Atlanta Java Software Symposium:
www.nofluffjuststuff.com/2003-10-atlanta/index.jsp
Contact: Jay Zimmerman, jzimmerman@nofluffjuststuff.com, (303)469-0486


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.

Velocity by Erik Hatcher
Velocity is a light-weight, yet powerful, Java-based template engine from
Apache Jakarta.  J2SE currently lacks anything comparable, but generating
from templates is a feature all applications need.  Velocity is the leading
Java templating solution. This presentation will first introduce Velocity's
straightforward syntax and usage, and then explore its benefits in several
key areas such as customizable e-mail templating, dynamic web interfaces,
and code generation.  Several production uses will be discussed including
JNLP generation for WebStart applications, integration with JSP and Struts,
and finally the interesting use of Velocity within Erik's BlogScene
application.

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