Join us for the Fall Edition of the Rocky Mountain Software Symposium: November14-16th
- Rocky Mountain Software Symposium: Fall Edition
When: November 14-16, 2003
Where: Marriott Denver West
Don't miss your chance to choose from over fifty education and solution
based sessions (see below for details) at the Rocky Mountain Software
Symposium: Fall Edition. You have the opportunity to attend one of the
best Java & related technology conferences offered and is located right
here in Denver. Please see the session listing below for further
* 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,
contact Jay Zimmerman, RMSS Symposium Director at
The early bird registration for RMSS 2003 is $595/person and is
available thru 10/14/03. We have a special
$50 discount available to all XPDenver members. Please use the discount
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
Rocky Mountain Software Symposium: Fall Edition 2003
JDO and Transparent Persistence by Dion Alamer
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
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
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
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> 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
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)
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.
Performance Testing by Mike Clark
Tuning EJB applications is like a wicked game of Twister. You end up
using arms and legs to keep the performance dials in perfect harmony.
And just when you think you've got it all under control, tweaking code
or changing the runtime environment can send performance into a death
spiral. In this session we'll tour some common pitfalls related to the
EJB performance tuning process discussed in the upcoming book, "Bitter
EJB". We'll sacrifice an application with a familiar antipattern as a
crash test dummy for performance testing. Then we'll improve its
performance in a stepwise fashion using a disciplined performance
testing methodology driven not by irrational fears or wild speculation,
but rather by automated tests that tell no lies. As a result of
attending this session you'll be able tune EJB applications with more
confidence and less stress.
Test-Driven Development with JUnit by Mike Clark
Testing is the cornerstone of building high-quality software, but it
doesn't have to be yet another stumbling block to meeting schedules. In
fact, writing tests can actually accelerate the development pace while
improving quality once the synergy between design and testing is
realized. You might even find it makes programming fun again! This
session will be a technical primer for writing and running automated
tests using JUnit, an open source Java testing framework. We'll practice
the principles of test-driven development through an example to design
flexible software in the face of change. We'll also tour some
complementary tools including Ant for build and test automation, Cactus
and HttpUnit for testing J2EE applications, JUnitPerf for performance
testing and FIT for acceptance testing . This is a 3 hour session.
Building Real World Apps with JSF by Bill Dudney
This presentation is on building real world applications with JSF. Most
of what we find in the RI and the spec is about the technology itself
and very little about how to write encapsulated applications with JSF.
This presentation is a practical hands on discussion of how to build a
real world JSF application. The focus is on moving towards the vision of
component based application assembly in the WebTier, i.e. keep the UI in
the UI and 'assemble' it with backend components with event listeners. I
will show the attendees how to build a good UI with JSF
(architecturally, not pretty looking ;-) and how to connect that UI to a
database. I will also show techniques and patterns for connecting to
'the backend' through session beans as well as through plain old java
objects (POJO's) using Relational/Object binding tools as well as JDBC.
The discussion will be very practical and focused on keeping the UI code
in the UI and the rest of the code out of the UI.
J2EE AntiPatterns by Bill Dudney
This session is about AntiPatterns in building applications with J2EE,
but the audience is not left high and dry stuck in their AntiPattern.
One or more refactorings are presented as a means to get out of each
AntiPattern. AntiPatterns for each major area of the J2EE specification
will be covered. Each AntiPattern is presented with practical
information about how to recognize the AntiPattern, what will likely
happen if the AntiPattern is not address and how developers get caught
in the AntiPattern in the first place. Next an example of code or design
stuck in the AntiPattern will be presented which will provide the segue
into the Refactoring(s) that provide the way out of the AntiPattern. The
refactoring will focus on taking the AntiPattern example through the
mechanism of the Refactoring step by step until the AntiPattern is gone.
In essence the AntiPatterns in this book formalize the concept of 'code
smells' that Fowler discusses in his great book on Refactorings. The
discussion will cover each of the major sections of the J2EE API set.
Anti-Patterns in Using the Jakarta Projects by Bill Dudney
This presentation is on Pitfalls in using selected software from the
Jakarta project. One or more refactorings are presented as a means to
get out of each Pitfall. Pitfalls for Struts, Ant and Cactus will be
presented. Each Pitfall is presented with practical information about
how to recognize it, what will likely happen if the Pitfall is not
address and how developers get caught in the Pitfall in the first place.
Next an example of code stuck in the Pitfall will be presented which
will provide the segue into the Refactoring(s) that provide the way out
of the Pitfall. The refactoring will focus on taking the Pitfall example
through the mechanism of the Refactoring step by step until the Pitfall
Alternatives to Swing by Ben Galbraith
Designed for both GUI newbies and Swing experts; introduces three
alternative frameworks to Swing.
Generating Professional PDFs with Java and XSL-FO by Ben Galbraith
This session covers the interesting XSL-FO spec and doing cool things
with FOP and RenderX. Will also cover issues relating to professional
printing, such as dealing with CMYK and spot colors.
Validating Ant Build Files by Ben Galbraith
Ant 1.6 finally allows you to use XML namespaces in your build files.
Come see where you can get a schema to validate Ant build files and how
it can improve your Ant experience.
Code Generation in-the-small with Ant, XML, and XDoclet by Stuart
By now, everyone knows that Ant is "make on steroids." Beyond its
usefulness in managing standard application builds, Ant is particularly
useful for code generation in-the-small. "In-the-small" implies code
generation techniques that do not require commitment to a particular
framework or approach. Instead, code generation in-the-small uses simple
string manipulation, regular expressions, and XML parsing to add power
and flexibility to *your* project implementation, without radically
changing the way you code. This talk will demonstrate the Ant tasks and
extensions most suited to
code generation, including XSL transformations and XDoclet.
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
Advanced Servlets by Jason Hunter
This talk, given by the author of "Java Servlet Programming" (O'Reilly),
will teach you the latest and greatest on servlet programming. We'll
cover servlet best practices including: choosing a servlet framework,
making performance optimizations, handling configuration files, how to
think of sessions, caching strategies, and making file downloads work
reliably across browsers. You'll also learn what's coming next in
What the X is XQuery? by Jason Hunter
XQuery, if it lives up to expectations, may be the most important thing
to happen in server-side programming this year. XQuery is a W3C
specification for querying XML or anything that can have an XML facade
such as a relational database. It has the backing of all the big
players including Oracle, IBM, BEA, and Microsoft, and has several open
source implementations as well. XQuery makes possible the exciting
possibility of a single query that combines an incoming purchase order
in XML format, an archive of catalog data also in XML format, and an
inventory system held in a relational database. In this session you'll
learn how to use XQuery, when to use XQuery, and which implementations
Web Services Tutorial in Java by Jason Hunter
This is not another "fluff piece" about web services but rather a
get-your-hands-dirty practical guide to creating and consuming web
services using the latest toolkits. You won't be bored seeing piles of
SOAP envelopes and WSDL descriptors. Instead, you'll learn how best
to consume web services like what Google and Amazon offer, see how SOAP
differs from REST, and learn to use both Apache Axis and JAX-RPC as
implemented in Sun's JWSDP. You'll also see how easy it can be to set
up your own web services, although we intentionally don't cover the
advanced details of web service deployment as it's still an area
undergoing major changes.
Core Language Changes in J2SE 1.5 by Jason Hunter
J2SE 1.5 will introduce a number of significant language enhancements,
with the goal to make programming in Java more expressive,
developer-friendly, and safer, while minimizing incompatibility with
pre-existing programs. The language changes include: generics, typesafe
enums, autoboxing, an enhanced "for" loop, a static import facility, and
a general-purpose metadata facility. This talk describes the proposed
changes and shows how they work together to improve the Java language.
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
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
>From the book of the same name, this talk examines the consequences ofusing concurrency-control mechanisms (most notably Java synchronization
blocks and database-style transactions), and how to build a system that
will continue to scale in the face of contention.
Effective Enterprise Java: Principles by Ted Neward
>From the book of the same name, this talk investigates the coreprinciples that a Java developer or architect must keep in mind when
designing, implementing and maintaining an enterprise Java system.
Discovery & Lookup of Cooperating Distributed Services by Paul Perrone
Many Java and J2EE development approaches resort to simple look ups of
distributed services based on a known URI and name, or simply co-locate
services within the same process environment. What if you were to infuse
the capability to build a cooperating and federated network of services
that could discover each other and new features offered by each other in
order to coordinate in accomplishing tasks? This talk describes the open
standards-based Java interfaces available to you for achieving this goal
and presents a design of one such solution.
Wireless Communications for Distributed Services by Paul Perrone
Low cost and easy to configure local area wireless communications
networks has opened the floodgates for organizations ranging from bars
to retail stores to construction sites to offer a variety of wireless
application services to their customers and employees. However, fixed
and temporary obstructions and interferences require a design that is
reliable and available. This talk describes the issues and Java-based
design of a low-cost wireless communications approach for enabling
distributed applications to communicate in a reliable and available
Securing Distributed Applications by Paul Perrone
The array of options available to the Java and J2EE developer for
infusing security into their applications is dizzying. Throw on top of
that the need to know where and when to use each technology and how the
technologies integrate, and you have a recipe for nausea. This talk ties
together some of the Java and J2EE security piece parts by describing
the design of an authentication, authorization, and confidentiality
solution to securing applications and data distributed across an
Eclipse IDE by Nimret Sandhu
This talk will focus on using IBM's Eclipse IDE for Java projects.
Nimret will talk about using the Eclipse's IDE's extensive features most
effectively in your java projects - from perspectives to it's cvs
integration. He will also talk about the refactoring capabilities of the
IDE and it's extensibility via plugins.
Transitioning to Agile by Alan Shalloway
More and more companies are beginning to see the need for Agile
Development. It is becoming clear that attempting to get full
requirements up-front and having a completely planned, rigid approach to
software development doesn't work but is more of a "hope over
experience". How to proceed isn't so clear. Do we go with the Rational
Unified Process (RUP), XP (eXtreme Programming), Scrum, or even another
methodology? The investment in the new techniques seems daunting,
expensive and by no means assured of success. The groundbreaking book
"Extreme Programming Explained" made it sound like an all or nothing
approach. Given it's controversial practices and mantras, this has been
a leap few managers have been willing to make. However, there are ways
to transition to agile that are straightforward, intuitively clear,
comfortable and risk adverse.
Emergent Design: Design Patterns & Refactoring by Alan Shalloway
The two approaches of creating quality, high-level, up-front designs
with design patterns or relying on emergent design using refactoring as
espoused by XP seem opposed to each other. This seminar illustrates why
design patterns and refactoring are actually two sides of the same coin.
Refactoring is very important as a method of improving design to
accommodate new requirements. It is often touted as a way to fix code
mistakes. However, avoiding the code mistakes in the first place is a
better way to go. In this case, refactoring is used to accommodate
design changes required by new requirements.
The Need for Agility by Alan Shalloway
Perhaps you've heard the phrase "paralysis by analysis," where all too
often project staff spend too much time on analysis and design. On the
contrary, they might spend too little time on the initial planning and
instead leap right in to the coding. On one hand, there is great value
in getting complete requirements and doing up-front design. Conversely,
we know the requirements are going to change. Furthermore, the more
work we do up-front, the longer it takes until we can get feedback about
what we've done. Both feedback from the customer and feedback on the
technical approach we've taken, are extremely important. Delays in
getting this information dooms many projects. This seminar will review
these issues and explore how light methodologies can be more useful in
short development cycles.
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
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.
Agile MDA by Gyl Savoie
This presentation examines an automated approach for translating
business models into the application code necessary to implement a
business solution. Development projects frequently proceed from business
definition directly to coding tasks. This ignores the intermediate
application-specific layer of definition, and contributes to deviations
from an organization's platform-specific architectural standards. The
application model is where business requirements are architected to a
platform-specific technology implementation. Lack of attention to this
layer contributes to lack of continuity between architectural design and
the implemented code. A model-driven and pattern-driven approach to
development introduces this layer. The use of transformation patterns to
change business requirements into a platform-specific model enforces
J2EE architectural standards and assures the best coding standards.
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.
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.
Bitter 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. This is a 3
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.
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).
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!
Practical JMX: Separating System Facilities from Application Logic by
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.
Squeezing Java by Alan Williamson
Java is a very powerful language, and while it offers the developer a
rich array of tools, the fundamentals mustn't be overlooked. Improving
your code at the core layer will result in great improvements in
efficiency and producing (hopefully) less bugs. We'll look at the do's
and don'ts of programming and learns lots of hints and tips that will
accelerate your Java coding.
[Non-text portions of this message have been removed]