No Subject

Agile MDA by Gyl Savoie
Model Driven Architecture can be agile. This presentation will illustrate
how patterns and models can work together to separate the architectural code
from the application code. We will explore how a custom pattern framework
can be automatically applied to a domain model to create the infrastructure
of a complete application. This process can be used iteratively to implement
code changes through business model changes while preserving previous code
extensions. We will investigate how this separation of concerns between
application and architecture can ensure a consistent and maintainable
application.

J2EE Web Foundation by Sue Spielman
J2EE 1.4 is the next generation of the Java Server Enterprise platform. Find
out what new features have been included in JSP 2.0 and Servlet 2.4 for
doing enterprise web development. This session will take a look at the J2EE
1.4 landscape to see what's hot, what's new, and what's changed in the areas
related to Web development. We will take a functional look at the JSP and
Servlet arenas regarding web development. With JSP 2.0, we'll talk about
using the new expression language, JSP fragments, .tag files, and Simple Tag
Handlers, as well as how to use the JSTL in your JSPs. We'll also look at
using new features in Servlet 2.4 including: deployment descriptor changes,
building better filters, and how to use the new Servlet APIs to handle web
event listeners in your applications. This will be a functional session with
code examples throughout.

JSTL - The JSP Standard Tag Library by Sue Spielman of Switchback Software
The JSP Standard Template Library provides custom tags that follow a base
design philosophy that allow page authors to work in a script-free
environment. Attendees of this session will get a look at what the JSTL is,
along with a detailed description of the available custom tags including:
iteration, conditional processing, expression language support, XML
processing, XSL transformation of XML documents, I18N-capable support for
localized formatting and parsing, and database access (SQL). JSTL is being
developed through the Java Community Process as JSR-52 and is included in
the Java Web Services Developer Pack (Java WSDP). We'll look at the various
functional areas that are provided in the Library, as well as take a
detailed look at how to use some selected tags. Come find out how you can
take advantage of the features of the JSTL in your Web application
development.

Developing Applications with Struts v1.1 - Advanced by Sue Spielman
If you're familiar with Struts or you're getting ready to use it as the
framework for your enterprise application development, this session is for
you. This is not an introduction to the Struts framework, but rather is an
in-depth look at the framework and how to make the best use of it in web
application development.  This session will include learning and using all
of the new features available in Struts v1.1.

This session just about begins where the Using the Struts Framework to Build
Enterprise Applications session leaves off. In that session the basics are
covered, in this session we put the pedal to the metal and go much further
in-depth into all that Struts can do. We will basically build an application
that shows how all of the features work and can be used in the real world.
Get down and dirty (coding that is) with the author of 'The Struts
Framework: Practical Guide for Java Programmers'.

AOP with AspectJ and Eclipse Plugin by Venkat Subramaniam
OOP is currently the most popular and practical software development
approach. However, OOP has its limitations, especially when it comes to
separation of concerns that are global and crosscutting in a large
application. Aspect Oriented Programming addresses this issue of managing
the complexity and AspectJ is an extension to Java to realize AOP. In this
presentation, we will introduce AOP and show how you can implement the
concepts using AspectJ and its Eclipse plugin.

Advances in Web Services by Venkat Subramaniam
Web Services is gaining a lot of popularity. Several organizations are
beginning to implement serious systems and components using web services.
Web services promise greater interoperability across application written in
different languages and running on different platforms. However, much
concern exists over the practicality of the solution, from the point of view
of security, transactions, scalability, performance and infrastructure. This
presentation will first introduce the audience to implementation of web
services and present details on advances in the areas mentioned. Several
working examples will be presented to illustrate the concepts.  This is a 3
Hour session.

Prudent OO Development by Venkat Subramaniam
Developing with objects involves more than using languages like Java, C#,C++
or Smalltalk for that matter. How object-oriented is our code? >From C++
time to time, the OO paradigm can stump even expert developers. In this
presentation the author will present some of the challenges that are
fundamental in nature. Then he will present some principles and good
practices for prudent development of OO code.

Building Web Applications with the Tapestry Framework by Eitan Suez
Tapestry is an elegant and powerful framework for building web applications.
This session will introduce you to building web applications using Tapestry.
The roots of this framework and its philosophy will be discussed.  One major
goal of the Tapestry framework is to provide an object-oriented model for
the web, which in turn promotes simplicity and flexibility in web
applications.  Second, Tapestry is inherently designed to provide
scalability in the web tier transparently.  One of my favorite quotes from a
developer who has used Tapestry is "Tapestry frags the snot out of
frameworks like JSF, Struts, and the like."  Come see for yourself what the
hype is all about.

Integrating Castor into your Java developer Toolset by Eitan Suez
Castor is an open source data binding framework for Java."  In this session,
Eitan will walk you through all about Castor, why you should use it, and how
it simplifies your job as a software developer.  The two principal
components of this open-source framework are Castor XML and Castor JDO.
You'll learn how to apply Castor XML to various tasks including
configuration, and how to effortlessly marshal your objects as XML over
HTTP.  Combined with Castor JDO, you'll discover how simple the task of
serving content on the web becomes.  Note: This is a 3 hour session with a
15 minute break.

Java Persistence Frameworks by Bruce Tate
When your application is too complex for pure JDBC, you need to consider
persistence frameworks, but the choices are daunting. Learn what makes a
good persistence framework. Learn some of the common pitfalls around data
persistence, and what add-ons are important for delivering good performance.
You'll first learn about the principles of persistence frameworks. Then, you
'll be able to compare and contrast the many Java persistence solutions,
including in-depth discussions with Hibernate and JDO code examples.

J2EE vs. .net by Bruce Tate & Ted Neward
What's hype and what's reality? Find out what developers like about each
platform, and what's missing. You won't learn who will win the war for
server dominance, but you will find out the key strengths and weaknesses of
each platform, including the underlying Java and C# languages; strategies
for presentation; database, messaging and transactional models; and the
other features that developers want to know. We'll leave the politics out of
this discussion, and focus on the technical issues.

JDO vs. EJB by Bruce Tate
Recently, EJB entity beans with container-managed persistence have come
under fire. Though EJB 2.0 and 2.1 make some much-needed improvements, they
may not go far enough. JDO can be an attractive persistence alternative for
some applications. Learn why in this session. We'll compare code examples
for each, and look beyond technical issues to understand the strengths and
weaknesses of each approach

Btter EJB - Common programming traps with EJB by Bruce Tate
Bitter EJB is another Java antipatterns book from the author of Bitter Java,
and three new Manning authors. In this  session, we'll look at some EJB
examples, and discover some basic EJB pitfalls. We'll then discuss remedies.
We'll look at session beans, stateful session beans, EJB CMP, persistence
alternatives, and messaging antipatterns. We'll have plenty of code
examples, from the book Bitter EJB.

Hibernate Overview by Bruce Tate
Hibernate is a popular new persistence framework. It allows transparent
persistence. It's based on reflection, so there's no byte-code enhancement.
Best of all, it's an OpenSource technology, so the price can't be beat.
Learn the basics about Hibernate. In this session, we'll learn about how
Hibernate works, and look at some mappings and code.

Naked Objects by Dave Thomas
What if you never had to write a user interface again? What if you could
simply expose your business objects directly to the end user? How would this
affect your productivity? The way you work? The flexibility of your
applications? Is this even possible? Sometimes, yes. This talk describes a
style of application development, Naked Objects, where you write just the
business objects, and a framework lets your users interact directly with
these objects.

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.

Introduction to Pragmatic Programming by Dave Thomas
Software projects still run late, over-budget, and under-featured.  Managers
ask their developers to work insane hours anyway, all in the face of
changing technologies and changing requirements.  Walking on water and
developing software from a specification are easy if both are frozen.  But
in today's business climate, everything is undergoing constant change;
nothing is frozen.

Pragmatic Mock Objects by Dave Thomas
Effective use of Mock Objects can make apparently untestable code testable.
This is a good thing: testing not only reduces bug rates, but structuring
code to be testable improves the design of the overall system, making future
maintenance and enhancements easier.

This talk concentrates on how Mock Objects can be used to allow you to test
code that relies on things apparently outside your control: databases,
incoming user requests, timers, web services, and so on.  We look at
different strategies for mock objects, from simple do-it-yourself
implementations through to full-blown frameworks. We also look at simple
dynamic techniques which reduce the time needed to implement and maintain
the mock object code.

Pragmatic Version Control by Dave Thomas
A team using version control properly can produce releases more reliably,
fix bugs in prior versions more accurately, and develop software in parallel
more efficiently. Despite these benefits, roughly 40% of teams use no
version control at all, and many of the remaining 60% use it ineffectively.

This talk focuses on the practical use of version control using the popular
and freely-available CVS system. It is recipe-based, meaning that teams can
match material in the course to their needs immediately. Learn how to manage
vendor branches, the easy way to prepare for releases, and the simple way to
back out last week's good idea (that turns out not to have been so good
after all).

Introduction to Aspect-Oriented Programming and AspectJ by Glenn Vanderburg
Aspect-Oriented Programming is a relatively new approach to solving some of
the weaknesses of object-oriented programming.  AOP doesn't replace OOP;
rather, it complements OOP, melding with object-oriented designs to handle
certain issues - certain *aspects* -- that objects don't deal with
particularly well.  This talk explains the principles of AOP, illustrates
the problems it is intended to solve, and introduces the most popular
aspect-oriented tool currently available: the Java-based AspectJ system.

Tag-Oriented JSP Design by Glenn Vanderburg
Custom tags -- not other people's tag packages, but the ones you write
yourselves -- are extremely powerful tools for JSP-based applications.  They
can improve your design and clean up your code.  Unfortunately, tag-oriented
JSP development is underused and undersold.  This talk includes a brief
intro to the basics of custom tag development, but the focus is deeper:
sophisticated tag programming tricks, design techniques, useful ways tags
can cooperate with each other, and so on.  Learn how to take control of JSP
and turn it into a language that really supports your application.

Software Development Heresies by Glenn Vanderburg
Much of what you were taught about software development is wrong.  Much
"conventional wisdom" is anything but wise.  Many of the most loudly
heralded technologies are deeply flawed.  What's going on?  Why does our
industry keep bouncing from one new technological or methodological savior
to the next?  And why do we keep thinking "this one's really it"?  Will we
ever learn?  Come hear some straight talk about the snake oil you've been
sold over the years, and see if you're being sold some more right now.
Bring your own stories of programming's misguided movements and hideous
hypefests to share with us!

Project infrastructure best practices by Glenn Vanderburg
When we talk about making development projects successful, people tend to
focus on architecture and design techniques, modeling tools, new
technologies and paradigms of programming, requirements    gathering, and
methodologies.  But sometimes the difference between success and failure
comes down to much more mundane issues, like project infrastructure.  Source
code control, bug and change management, build automation, test automation,
project communication, code organization ... all of those things can have a
surprising impact on your project.  (And if they're done badly, that impact
is something you could do without.)  Come learn about the kinds of
infrastructure that some of the best and most experienced teams use.  We'll
look at different kinds of infrastructure and why they're all important to a
project.  We'll also talk about various tools you can use, and their
strengths and weaknesses.

Practical JMX: Separating System Facilities from Application Logic by Greg
Vaughn
This talk gives a short overview of JMX, then jumps straight into a case
study examining why JMX was chosen, how it helped, and how its use has
influenced future architectural plans all the while gradually picking up
more details of JMX. The end result is a fully reusable component that
monitors a JMS dead letter queue for rolled-back deliveries and requeues the
messages after a configurable time delay.  The component is not only
reusable, but has already been reused, and the QA department is extremely
pleased at the quality of it. The component nature of JMX was a huge factor
in the success of it.

Practical Performance: When IO is the bottleneck by Greg Vaughn
This talk discusses a batch-mode application that initially was projected to
require 3 hours to run 100,000 records of data. The process is very IO
intensive. Through several strategies (NIO, SQL optimizations, refactoring
the algorithm, etc), the runtime was reduced to 30 minutes. The application
was profiled at each step and the lesson learned helped to drive the next
optimization attempt. The end result of the code was not only a factor of 6
faster, but also better factored and easier to read.
--- End Session Listing ---


October Meeting - New Features of J2SE 1.5 (Tiger)

Burr
AJUG President