Early Bird Discount Ends May 9th: Join Us for the Central Ohio Software Symposium 2005 coming to Columbus on June 3-5th (Session Agenda Enclosed)

[Jay Zimmerman <jzimmerman@xxxxxxxxxxxxxxxxxxxx>]

Central Ohio Software Symposium 2005
www.nofluffjuststuff.com/2005-06-columbus/index.jsp

The No Fluff Just Stuff Software Symposium 2005 tour is pleased to
announce the return of the Central Ohio Software Symposium coming to
Columbus on June 3-5th. You will have the opportunity to attend the best
technically focused Java event anywhere. We make this claim based on the 
following:

1). Excellent Speakers with unparalleled access by attendees
2). Limited Attendance = 250 Registrants Max
3). No Vendors, No Sales Pitches, No Marketecture
4). Unmatched Value – less than 1/3 of the cost of a national conference
5). Since 2002, we have hosted over fifty (55) software conferences
throughout the U.S. and Canada with over 8,750 attendees.

The No Fluff Just Stuff Software Symposium Series caters to individual
developers, development teams, technical project managers, architects
and independent consultants. The Central Ohio Software Symposium
will offer five (5) concurrent sessions over three days for a total of 
fifty-five
(55) sessions to choose from. COSS 2005 will feature presentations on
the following topics:

* Core Java
* Client Side Java
* ServerSide Java
* Architecture
* XML
* Web Services

Featured Speakers include:
Dion Almaer, former Editor-in-chief of TheServerSide.com
Venkat Subramaniam, author of the soon to be released "Practices of an 
Agile Developer"
Bruce Tate, co-author of “Better, Faster, Lighter Java”
Ted Neward, author of “Effective Enterprise Java”
David Geary, co-author of “Core JSF”
Dave Thomas, co-author of “The Pragmatic Programmer”
Stuart Halloway, author of "Component Development for the Java Platform"

Registration Fee:
Individual: $675 special early bird discount valid thru May 9th or
whenever we sell out. An additional $50 discount is available to all
JUG members for individual registrations thru May 9th. Please
use the discount code, nfjs2005spec when registering.

Group Rates: (Valid thru 5/09/05)
5-9 Attendees: $600/person, after $675
10-14 Attendees: $575/person, after $650
15-24 Attendees: $550/person, after $625
25-over Attendees: $525/person, after $600

The Registration Fee includes the following:
1). All Access Pass to the three day symposium
2). Handouts from all sessions attended w/binder
3). CD with all presentational content @ registration
4). Custom NFJS Laptop/Backpack

Venue = Clarion Inn Dublin @ $99.95/night

Go to www.nofluffjuststuff.com/2005-06-columbus/index.jsp for more details.

Questions/Comments: Contact Jay Zimmerman:
jzimmerman@xxxxxxxxxxxxxxxxxxxx or (303)469-0486

***********************************************************************************************************************************************************
Central Ohio Software Symposium 2005
-Session Schedule-

June 3, 2005
12:00 – 1:00 PM: Registration

1:00 – 1:15 PM: Welcome/Overview

1:15 – 2:45 PM:

Session #1: Spring Overview by Bruce Tate
The Spring framework is one of the fastest growing open source 
frameworks. New job postings are gaining rapidly, and many customers are 
adopting Spring instead of heavier alternatives. In this session, we’ll 
introduce Spring. You’ll see how Spring can give you much of the power 
of EJB, without the complexity or pain. Spring uses concepts like 
dependency injection and aspect oriented programming to ease standard 
enterprise development. Spring developers write plain, ordinary Java 
objects (POJOs), instead of sophisticated components.

Session #2: Introduction to Java Reflection by Stuart Halloway
Reflection is writing code that manipulates itself. Well-written 
reflective code automates a broad class of repetitive, error-prone 
programming tasks. Poorly-written reflective code obfuscates programs 
and destroys the benefits of the type system. We'll focus on the former.

REFLECTIVE TASKS COVERED IN THIS TALK

* Discovering class members
* Dynamically accessing fields, methods, and constructors
* Bypassing the Java language protection modifiers
* Converting between objects, XML, and relational data
* Generating new classes at runtime
* Intercepting method calls and simple aspects
* The reflection security model

All of the examples in this talk are presented using the Java language. 
For a more advanced discussion, including examples from other reflective 
languages, consider the "Metaprogramming: Making Patterns Better" talk.

Session #3: OpenSource Ecosystems by Dave Thomas
Open Source communities produce high quality software with little 
management and (typically) no pay. Most people looking at open source 
focus on using this software in their projects. This talk takes a 
different tack: how can we bring the open-source way of developing 
software into our corporations, improving the way we write software? It 
turns out the answer has a lot to do with people, and a lot to do with 
agile software development.

Session #4: JavaServer Faces Fundamentals by David Geary
Poised to become the preeminent--not to mention standard--Java web 
application framework, JavaServer Faces (JSF) is the next big thing for 
server-side Java. Come find out what all the fuss is about in this 
cutting-edge session given by a member of the JSF Expert Group. Learn 
what JSF has to offer, how it compares to Struts, and how you can start 
using it today. This session is an introduction to JavaServer Faces; 
essentially a series of HowTos for developing JSF web applications.

Session #5: Creating Polished Swing Applications by Ben Galbraith
Too often, Swing applications are slow, ugly, and hard-to-maintain. It 
turns out that it doesn't have to be this way. Swing can be used to 
create highly-responsive, beautiful applications that are very 
maintainable. If this isn't consistent with your own experience, don't 
feel bad; its not very obvious how to make Swing sing. In this session, 
I explore three topics that lead to much better Swing applications:

- Proper Swing threading
- High-quality third-party Swing look-and-feels
- Good practices for coding Swing applications

In the threading portion of the session, I explain Swing's event 
handling architecture and its implications for Swing applications. 
Understanding this topic is crucial to creating highly-responsive Swing 
apps. I demonstrate how to use this knowledge in the form of many 
live-coded examples, and I show how frameworks like SwingWorker and 
FoxTrot can make this easier. Java's default look-and-feel, Metal, is 
awful (and in my opinion, the "Ocean" theme in JDK 5.0 doesn't do enough 
to improve it); you should stop using it immediately. But creating 
good-looking applications is sadly more than slapping in a 
look-and-feel; you must also take care to understand the principles 
behind attractive layouts. I spend the second part of this session 
exploring how to make your Swing applications look great through a 
combination of third-party look-and-feels and layout techniques.


2:45 – 3:15 PM Break













3:15 – 4:45 PM

Session #6: Ruby for Java Programmers by Dave Thomas
Ruby recently enjoyed its tenth birthday. Instead of cake and candles, 
the community celebrated by releasing a wave of new libraries and 
frameworks that make Ruby programming even easier. This talk features 
some of the best of these, as we explore Ruby and the web. If you can't 
help thinking that there must be an easier way of developing web 
projects, come and join us as we construct an MVC-based Ruby application 
using the very latest libraries and tools. You'll get a taste of Ruby, 
and also a feel for some of the power and productivity gains offered by 
this remarkable language.

Session #7: Class Loading in Java: Building Dynamic Systems Without Pain 
by Stuart Halloway (3 Hour Session)
One of Java's greatest strengths is its flexible deployment model. In 
this session you will learn how Class Loaders facilitate deployment, and 
how to troubleshoot Java and J2EE Class Loading problems. We will begin 
by looking at the basic class loading model provided by the java 
launcher, including the classpath, extensions path, and bootstrap path. 
Next, we will see how J2EE, Ant, browsers, and other container 
applications extend this model, using SecureClassLoader and 
URLClassLoader to dynamically load new classes at runtime. These 
techniques allows side-by-side deployment of multiple versions of the 
same class, and redeployment of changed classes without shutting down 
the Java virtual machine.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.

Session #8: Making the Most of XML by Ben Galbraith
For many of us, XML has become a ubiquitous presence in application 
development, whether parsing, validating, or manipulating it. For many 
of us, all that XML is coupled with pain, in the form of tedious APIs 
(like, say, the W3C DOM API) and confusing technologies (oh, I don't 
know, W3C XML Schema?). In this session, I share the following tips for 
making the XML in our lives a little easier to deal with:

- Use StAX instead of SAX
- Use StAX to create XML
- Use JDOM instead of W3C DOM
- Use XPath to select XML
- Use Jaxen to enable XPath over custom trees
- Use RELAX NG instead of DTD or WXS
- Use Trang when DTD/WXS output is required
- Use Sun's RELAX NG Converter when WXS input is required
- Consider RELAX NG's compact syntax
- Use Schematron to extend schema languages
- Consider XML namespaces for versioning
- Ignore unknown namespaces

Session #9: Shale: The next Struts? by David Geary
Struts is the most popular Java-based Web application framework today, 
but that's rapidly changing. There's a newcomer on the block, a leaner, 
meaner, better-designed framework loosely based on Struts that's poised 
to dethrone Struts as the reigning king of Java-based web application 
frameworks. That framework, of course, is JavaServer Faces. Craig 
McClanahan, the father of Struts and the co-spec lead for JSF 1.0, has 
proposed reinventing Struts for Struts 2.0 as a set of services for JSF 
applications. That new framework, which has no direct ties to Struts as 
we know it, is called Shale.

Session #10: Comparison of Lightweight Containers by Bruce Tate
Lightweight containers let you build a sophisticated application, with 
plain old Java objects (POJOs), and looser coupling than traditional 
alternatives. With the proliferation of new lightweight containers like 
Pico, Spring and Hive Mind, choosing an alternative can be daunting. 
This session shows why you would choose one framework over the others. 
These containers may be similar on the surface, but they are 
fundamentally different in several approaches. This session will start 
by showing you code for each of the containers, and compare the 
approaches. The examples will be very simple. Then, the session will 
show how services are integrated. Finally, you’ll see an overview of the 
unique features that each of the containers brings to the table. You’ll 
notice some similarities, and some striking differences:

4:45– 5:00 PM: Break

5:00 – 6:30 PM

Session #11: Creating Killer Graphics and Professional PDFs with XML by 
Ben Galbraith
You can do some pretty cool things with XML these days (despite what 
some curmudgeons in the technology world may claim). In the past few 
years, XML has solidified its place as the lingua franca of data sharing 
and data manipulation. But XML as a data transfer language is only 
marginally interesting. Things get really exciting when XML is 
dynamically transformed into other formats.

In this session, I focus on two XML formats which can be readily 
transformed into high-quality presentation-centric output formats. 
XSL-FO is a typesetting format for XML that can be readily converted 
into PDF (or Postscript and some other formats). SVG is a vector 
graphics language in XML -- a sort of open-source version of the popular 
Macromedia Flash format. SVG files can be converted into beautiful, 
completely scalable -- and interactive -- images.

Session #12: Class Loading in Java: Building Dynamic Systems Without 
Pain by Stuart Halloway (Continued)

Session #13: Ruby on Rails by Dave Thomas
The Ruby on Rails framework has exploded onto the scene over the last 
few months. Propelled by some genuine benefits, and fueled by a whole 
lot of controversy, Rails seems here to stay. So, is it a Java killer? 
(No.) Is it a great way to develop certain classes of web application? 
(Yes.) Does it really deliver the 10-fold increase in developer 
productivity that some have claimed? (It depends...) If you can't help 
thinking that there must be an easier way of developing web projects, 
come and join us as we construct an MVC-based Ruby on Rails application 
using the very latest libraries and tools. You'll get a taste of Ruby, 
and also a feel for some of the power and productivity gains offered by 
this remarkable framework.

You'll need a grounding in Ruby to get the most from this talk; if 
you're not already a Ruby developer you might want to attend the
Facets of Ruby talk before coming to this one.


Session #14: Felix: A bag of tricks for JavaServer Faces by David Geary
Okay, so you know a little about JSF. You understand managed beans, 
action outcomes and how to attach standard JSF validators to components 
in a JSP page. Perhaps you've even implemented a custom component or 
two. But there is a great deal of functionality that the average web 
application supports that JSF doesn't provide out of the box. For 
example, wouldn't you like to have JSF automatically place asteriks in 
front of labels for required fields? You are going to test your 
application, right? And don't forget to trap unauthorized use of the 
back button. How do you do all of that stuff in a JSF application? If 
those are the kinds of questions that keep you up at night, then this 
session is for you. We will explore the outer reaches of JSF development 
to illustrate how you can bend your next JSF application to your will.

Session #15: Lightweight Development Strategies by Bruce Tate
Based on the book Better, Faster, Lighter Java, this session will show 
the average enterprise Java developer why current technologies are 
inadequate. The session will focus on these basic principles:

A). Traditional object oriented development may work for large projects, 
but it’s not the right approach for most of the enterprise software that 
we build.
B). Certain characteristics of technology can improve your chances of 
success.
C). Some new open source technologies, like Spring and Hibernate, 
dramatically simplify programming by reducing complexity.

Many development teams use heavyweight development technologies to solve 
basic problems. We overuse EJB, we use XML where it’s not the best fit, 
and we needlessly complicate our lives in many other ways. We’ll look at 
process, architectures, and technologies that can simplify your code and 
save you money. When the session is over, you’ll have a good 
understanding of the techniques that you can use to do lighter-weight, 
simpler development projects. You’ll know the processes that the experts 
favor, and the tool kits that they use to simplify their lives.

6:30 – 7:15 PM Dinner

7:15 – 8:30 PM: Keynote by Dave Thomas, “Art in Programming”

Central Ohio Software Symposium 2005
-Session Schedule-

June 4, 2005

8:00 –9:00 AM: Continental Breakfast

9:00 – 10:30 AM

Session #16: Design Patterns Revisited: Taking advantage of dynamic, 
reflective languages by Stuart Halloway (3 Hour Session)
Attendees should attend the Introduction to Reflection talk, or have 
some experience using reflection or metaprogamming in a reflective 
language such as Java, Objective-C, Smalltalk, Python, or Ruby. 
Familiarity with the GOF book is helpful but not required.

Design patterns are recurring solutions to problems that consistently 
appear in software development. However, this does not mean that design 
patterns cannot be "solved", i.e. converted into language or library 
features. In fact, most of the original design patterns can be solved 
using dynamic language features such as reflection.

This talk covers specific design patterns, and shows multiple 
implementations of each, demonstrating how reflection and other dynamic 
techniques make the patterns invisible, freeing you to concentrate on 
solving *new* problems.

In part A I cover
Abstract Factory
Almost-Real Objects (a variant of mock objects)
Singleton

In part B I cover
Iterator
Flyweight
Observer
Dynamic Agile Development

Session #17: Herding Racehorses and Racing Sheep by Dave Thomas
Are you frustrated by experts who can't tell you what to do, or by 
junior team members who refuse to see the big picture? How can you best 
develop careers: both yours and those of your teammates and managers? 
How can we learn to apply experience more effectively, and why do the 
many approaches designed to tame complexity actually end up increasing 
it? Dave Thomas, of The Pragmatic Programmers, describes the solutions 
to these and other problems as he turns the Pragmatic Spotlight (and a 
good dose of twisted humor) on formal learning models, the Nursing 
profession, and streamlining sheep.

Session #18: The Politics of Persistence by Bruce Tate
This free-form session is intended to help attendees choose or validate 
a persistence framework. In it, the instructor will take questions from 
the audience, and tailor the session to the questions asked. Bruce will 
focus on three persistence frameworks: EJB, JDO and Hibernate. He’ll 
talk about the evolution of each of the frameworks. He’ll talk about the 
fundamental design philosophies of each, and what makes each unique and 
strong. But understanding technical strengths is not enough in the area 
of persistence. To make the best possible choice, a developer or 
architect must also understand the politics of persistence, and the 
marketing pressures that lead to the success or failure of each 
framework. The proposed common standard across JDO and EJB will get 
special consideration.

This format has been very popular among nofluffjuststuff attendees. It’s 
highly tailored to each audience, but still flows with good structure. 
When the session is over, you’ll have a better understanding of the 
major persistence frameworks in the Java space, and what makes each 
valuable. You’ll also understand how much of a role market share and 
technology play in the success or failure of a persistence framework.

Session #19: SWT Fundamentals by Ben Galbraith
The Eclipse project's SWT GUI toolkit provides one of the only viable 
alternatives to Swing for creating so-called rich client applications in 
Java. Whereas Swing paints its own widgets and has distinguished itself 
with a complex (and often obtuse) API, SWT relies on the host operating 
system for widget rendering and sports a simple, clean API. If your goal 
is to create a Java application that "looks" like a normal Windows 
application (or OS X, or Linux), SWT will revolutionize your world.

In this session, I introduce SWT from the ground up. I start at a 
high-level, but quickly move into the details of SWT's API. By the 
presentation's end, attendees will have a solid understanding of SWT, 
including:

- How to write a Hello, World SWT application
- How to use SWT layout managers
- Understanding event handling in SWT (including how to make 
applications as responsive as possible)
- Using SWT's advanced widgets

Session #20: XML made easy with XOM by Brian Sam-Bodden
XML is quickly becoming the common ground for disparate systems to 
exchange information and most Java developers deal with XML almost on a 
daily basis, whether is in deployment descriptors and configuration 
files or as the data format at the center of their applications. XOM is 
a new XML object model that strives to be easy to learn and easy to use. 
Based on similar principles to JDOM it takes XML programming in Java to 
the next level by taking correctness and simplicity as its guiding 
principles while striking a balance between the speed of SAX-based 
parsing and the manipulation abilities of DOM-like APIs.

10:30 – 11:00 AM: Break

11:00 – 12:30 PM

Session #21: Design Patterns Revisited: Taking advantage of dynamic, 
reflective languages by Stuart Halloway (Continued)

Session #22: Guerrilla Web Techniques by Scott Davis
Frameworks? We don't need no stinkin' web frameworks. OK, so maybe 
that's overstating the case. Web frameworks do plenty of good things, 
but sometimes they can also be golden handcuffs. Too many web developers 
fall into the trap of thinking, "If it can't be done by my web 
framework, then it simply can't be done." This presentation focuses on 
the cool things that you can accomplish by stepping out of your web 
framework and getting closer to the underlying technology. We'll take a 
detailed look at what really goes on during the request/response cycle, 
and how new techniques like AJAX allow you to break the mold. We'll look 
at the clever things you can do with MIME types, User-Agents, and HTTP 
Headers in general.

Old technologies like CSS, DOM, and JavaScript are experiencing a 
renaissance under the guise of new names like DHTML and AJAX. Google 
Maps and GMail are literally redefining our expectations of how rich a 
web application can be by using these technologies to their fullest 
potential. Come see what makes these sites tick, and how you can utilize 
the same techniques in your own site.

Session #23: Advanced SWT and JFace by Ben Galbraith
This session picks up where SWT Fundamentals leaves off. Among the 
advanced topics I discuss are creating custom SWT widgets and exploring 
tight native integration. I combine another compelling topic with the 
advanced SWT material: JFace. SWT is a more akin to AWT than Swing; its 
concerned more with wrapping native functionality than providing any 
high-level abstractions. JFace is an API on top of SWT that provides 
such abstractions. The combination of SWT and JFace is comparable to 
Swing. My coverage of JFace includes an introduction to several of its 
frameworks, such as the Viewer and Window frameworks, along with many 
examples. Learning JFace will enable you to write complex SWT 
applications much faster.

Session #24: Applied Object-Oriented Metrics by Brian Sletten
Object-oriented code metrics are a little like Artificial Intelligence: 
those who did it twenty years ago roll their eyes at the thought and 
prophesy the same ultimate failure at applicability now. Those who grew 
up with Java are approaching the topic with new eyes and are finding 
useful ways of incorporating metrics into their projects. Come hear 
about tools and ways to measure properties of software, how they might 
be beneficial and where you are likely to go astray with this approach.

Session #25: Beyond Java by Bruce Tate
The Java programming language has been tremendously successful. Many of 
the roots of its success may be surprising to the audience. But every 
major programming language has a limited life cycle. While it’s true 
that Java and .NET seem to be the only games in town, some alternatives 
are beginning to emerge. In this session, we’ll discuss some of the 
limitations of the Java language, and the impact that they might have on 
the productivity of Java developers. We’ll then look at some of the 
innovations around other frameworks and languages, and some of the 
features of those languages that boost the productivity of other 
non-Java developers:

• Typing, and why it matters
• Code blocks and closures
• Regular expressions
• Innovative frameworks


12:30 – 1:15 PM Lunch

1:15 – 2:15 PM Expert Panel

2:15 – 3:45 PM

Session #26: The Fallacies of Enterprise Systems (Architecture) by Ted 
Neward
There's a set of fallacies that every enterprise developer has fallen 
for at some point in their enterprise development lives, and
unless they've come to realize it early enough, all cause big trouble 
and painful learning experiences in the long run. In this talk, we'll go 
over the Enterprise Fallacies, discuss why they're so insidious and easy 
to fall into, and how developers can go about making sure they avoid 
them in the future. Discussions will be relative to both .NET and Java, 
as well as the emerging Web services stack, as the Fallacies know no 
technical boundaries.


Session #27: Complex Builds with Ant by Brian Sam-Bodden
Ant has revolutionized the way we build applications in Java and it has 
become a de facto standard in the Java world. As applications grow in 
complexity some developers are finding themselves dealing with ever 
growing and complex builds. Complex builds have to deal with Multiple 
Operating System, multiple Application Servers, multiple APIs and 
multiple stages of development. This talk would highlight some of the 
growing pains typically encounter in the evolution of an application 
build system and possible solutions and best practices that can be 
applied to several of these scenarios. With the arrival of the Ant 
version 1.6 many of the lessons learned with large projects have been 
now incorporated. Ant 1.6 can help you deal with complex builds efficiently.

Session #28: Advanced Swing: Architecture and Frameworks by Ben Galbraith
Are you spending more time plumbing your Swing applications than solving 
business problems? Has your Swing application grown out of control? This 
session is for you. In the first part of the presentation, I analyze the 
architectural problems that plague many Swing applications and present 
architectures that overcome these problems. These architectures are 
presented in terms of principles along with a reference implementation. 
You can therefore either adapt the principles to meet the needs of your 
existing applications, or incorporate the specific ideas of the 
reference implementation into your new projects. Fortunately, there are 
some existing frameworks that have done some of the architectural work 
already. I present some of these frameworks in the rest of the presentation.

Session #29: Testing the Web Tier by Scott Davis
Hopefully your test plan involves more than, "Well, it compiled..." 
JUnit is fast becoming a required part of the modern Java developer's 
toolkit. Unit testing your Java classes is a great start, but your test 
plan shouldn't stop there.

This talk will introduce several additional testing tools for the web 
developer -- HttpUnit, Canoo WebTest, and JMeter. These tools allow you 
to test a live website with no changes to the production code. Even 
better, you can test sites that have been implemented in technologies 
other than Java. You will see code examples and live demos of these 
tools in action. We'll talk about the differences between unit testing, 
functional testing, and performance/load testing. Come get "test 
infected" -- you'll never look at the development process the same way.

Session #30: Enterprise AOP by Dion Almaer
Aspect-oriented programming (AOP) has become a hot topic for enterprise 
development, with recent news of support by IBM, JBoss, BEA, Oracle, 
Eclipse, and IntelliJ. Behind the news headlines, however, are critical 
questions: How real is AOP for the enterprise? What problems can it 
solve today? How does it apply to enterprise applications? How can one 
make an informed decision about trying to use AOP? What is the best 
adoption strategy? What are the long term possibilities for AOP in the 
enterprise?

This session tackles these questions and show developers, architects, 
and technical managers how AOP can be used for enterprise Java 
application development. We provide a refresher of AOP concepts and show 
enterprise examples of how AOP works and where it can be beneficial, as 
well as discussing anti-patterns (i.e., how not to use AOP).

Examples discussed include error handling, policy enforcement, tracing, 
systems management with JMX, and more. The examples are implemented in 
the AspectJ programming language (a popular and seamless aspect-oriented 
extension to Java) and incorporate major J2EE technologies such as 
servlets, JSPs, and EJBs. We will also demonstrate using the AspectJ 
tools to work in an enterprise environment. At the end of the tutorial, 
participants will have a better understanding of both the potential and 
the pitfalls for applying AOP in a J2EE context. The tools used in the 
tutorial are all freely available as open source software, so 
participants will be able to use the techniques shown in their own projects.

3:45 – 4:00 PM Break

4:00 – 5:30 PM

Session #31: Creating Next-Generation, Highly Dynamic, Off-line Capable 
Web Applications with HTML and JavaScript by Dion Almaer
As recent high-profile web apps such as Google's GMail have shown, 
modern browsers are capable of natively rendering web apps with highly 
dynamic and compelling UIs - fetching server data without page 
refreshes, animating and manipulating page contents on-the-fly, even 
offline use. The line between web and "desktop" apps is blurring. 
Experienced web developer Dion Almaer (editor of TheServerSide.com) and 
noted Java desktop expert Ben Galbraith will describe and demonstrate 
these new techniques, including how to adapt modern web frameworks such 
as JSF and Tapestry to ease both the creation and maintenance of these 
types of applications.

Session #32: Effective Enterprise Java: Security (Java) by Ted Neward
Security's become a hot topic among enterprise developers in recent 
years, but to many developers, security is still the white elephant in 
the middle of the room. Discussions about security usually begin with, 
"Uh, we'll worry about that later", or, "Start with two really large 
prime numbers.....". Security isn't as hard as developers make it out to 
be, but it is something that developers need to face and recognize. In 
this talk, we'll extract the 10 Items on Security from Effective 
Enterprise Java and talk about them, giving developers the basic 
heads-up they need to have when building enterprise systems in Java.

Session #33: Testing the Web Tier, Part 2 by Scott Davis
JUnit is more than a Java testing tool -- it is a testing framework that 
can be extended to test non-Java resources as well. In the first 
presentation in this series, we examined three JUnit extensions that 
allow you to functionally test your website. In this talk, we'll look at 
three more tools that web developers should have in their toolkit: 
JsUnit, DbUnit, and the W3C Markup Validation Service. JsUnit allows you 
to test your JavaScript. Anyone who has done JavaScript development 
knows that cross-browser support of JavaScript is a tricky proposition. 
Rather than emulating a specific browser, JsUnit can literally launch 
different browsers and execute the test suite to ensure that the 
JavaScript code you wrote actually works.

DbUnit allows you to stage your database tables for unit testing 
purposes. You can insert and delete information as a part of your test 
suite. While the database isn't technically a part of the web tier, 
we'll show how the proper use of this tool allows you to test the other 
parts of the web tier with ease.

HTML compliance is difficult if not impossible to see just by looking at 
raw HTML. Browsers are reasonably permissive in terms of the HTML 
they'll render, but writing valid HTML ensures the widest possible 
audience for your site. We'll show you how to incorporate this free 
online service with JUnit.







Session #34: Advanced Object-Relational Mapping with Hibernate by Brian 
Sam-Bodden
Hibernate is rapidly becoming the tool of choice when it comes to 
Object-Relational Mapping in Java. For simple applications with fairly 
simple object models and database schemas, using Hibernate is fairly 
straight forward. Unfortunately for most of us real applications have 
complex object-models that need to be wired to sometimes ancient and 
convoluted database schemas. In this session we explore some of the 
advanced features of Hibernate and how you can use Hibernate to solve 
the hard problems of Object-Relational Mapping.

Session #35: Rules Engines by Dion Almaer
Rules Engines are powerful beasts which allow you to program in a way in 
which you specific rules and facts, rather than a linear set of 
instructions. It takes awhile to get used to "Thinking in Rules", but it 
gives you immense power for particular logical problems. You pass 
control HOW the rules are applied to the rules engine, and just give it 
the information it needs to get the job done.

Rules based systems are often great solutions for enterprise problems, 
and are uniquely useful for building so-called "business rules". Now you 
have an external view of your business, and can change behaviour via the 
rules rather than hard coding your application. Learn about the power of 
Rules based thinking in this talk, as we go through and show real 
examples of how it can help you out in your daily toil.


Central Ohio Software Symposium 2005
-Session Schedule-

June 5, 2005


8:00 – 9:00 AM: Continental Breakfast

9:00 – 10:30 AM:

Session #36: Test First Development by Venkat Subramaniam
Do you know that unit testing is more of an act of design than 
verification? What are its benefits? How do we write effective tests? 
How does unit testing relate to evolutionary design? How does it help 
you with refactoring? When should you write your tests? What are the 
types of tests you could write? These are some of the questions that you 
would ask if you are interested in Unit Testing. What is a better way to 
learn than practicing it? In this session the attendees will participate 
in designing and developing a small yet full application. Instead of 
PowerPoint slides, you will learn from example. The code you help 
develop will be available for free download on the speaker's web site.

Session #37: Cascading Style Sheets: a Programmer's Perspective by Eitan 
Suez
Today, the Cascading Style Sheets (CSS) specification is well supported 
by the major browsers (Mozilla, Safari, IE). CSS has become a practical 
tool for web content publishers that has helped turn heavy, buggy, and 
hard-to-maintain web sites into lean, clean, and stylish ones. CSS is 
sometimes stereotyped as a technology geared for graphic designers and 
artists. I beg to differ: I see CSS as a refactoring tool for content 
publishers and one that encourages content to become more strongly 
semantic. Come see a developer's perspective on CSS and how it can be 
applied to refactor your web content.

Session #38: Give the DB a break!: Performance and Scalability by Dion 
Almaer
What do we really mean by "performance" and "scalability"? This talk 
gets into the meat of problems which cause our applications to degrade. 
We will focus on issues such as problems caused by the database being a 
bottleneck for our application, and see how we can architect our 
solutions to bypass the issues, resulting in a solid system which scales 
with the increased load. Not only will we look at the factors, but I 
will delve into a couple of case studies to show how real world problems 
were solved!

Session #39: Applied Design Patterns by Brian Sletten
Just about every modern software developer has a copy of the Gang of 
Four "Design Patterns" book sitting on a shelf; many of them have 
actually read it. The dark secret of the patterns community is that 
there is often a large gulf between whiteboard simplicity and real-world 
complexity. Language choice plays a part in the design (and even 
importance) of patterns. The situation is made even more confusing by 
the fact that many of the core patterns have now been "voted off the 
island" for one reason or another. This talk will give a pragmatic 
overview of the motivations behind design patterns and will focus on 
applying a handful of the GOF patterns to example scenarios in Java and 
C#. A quick introduction to the role AOP plays in changing the patterns 
landscape will also be covered.

Session #40: J2EE Transaction Management: Techniques and Best Practices 
- Part I by Mark Richards
Although the EJB container isolates us from most of the complexities 
involving transaction management, there are still a number of things we 
need to be aware of when dealing with transactions within the J2EE 
container. Too often transaction management is an afterthought in the 
design and development process, which leads to applications that have 
problems with data integrity, data consistency, and overall stability 
and reliability. In this session we will explore the three transaction 
models that J2EE supports (Local, Programmatic, and Declarative), and 
discuss the advantages, disadvantages, and pitfalls within each of these 
models, when it makes sense to use each transaction model, and under 
what situations these models are appropriate and inappropriate. We will 
spend most of our time on the Declarative transaction model, otherwise 
known as container managed transactions (CMT). Within this model we will 
explore some common pitfalls and look at the best practices within this 
model. Through coding examples and real-world scenarios, you will learn 
how to properly handle exceptions, how to coordinate multiple resources, 
how to correctly use transaction attributes, and how the isolation level 
can affect transaction and application behavior. We will also discuss 
the problems encountered with Entity Bean data caching and data 
synchronization within the context of JTA transactions. This session is 
the first part of a 3 hour session.


10:30 – 11:00 AM Break






11:00 – 12:30 PM

Session #41: Applied AOP by Brian Sletten
Most people new to Aspect-Oriented Programming (AOP) are fed up with 
separation of concerns zealots explaining how great their techniques are 
at dealing with... logging. Ok, you get it. Logging is a cross-cutting 
concern that can be appropriately modularized. What else does AOP have 
to offer? A lot, it turns out. This talk will give an introduction to 
the motivations of AOP as well as a series of concrete examples drawn 
from enterprise and client side Java. Come learn how AspectJ-flavored 
AOP can begin to benefit you immediately either in development or 
production environments. Learn how to enforce architectural policies, 
find Swing threading issues, reduce the invasiveness of the Observer 
design pattern or even improve the reusability of your domain models.

Session #42: Agile Methodologies by Venkat Subramaniam
Agile development is picking up steam. You have most likely heard about 
eXtreme Programming(XP). What other Agile methodologies are you familar 
with and what do they bring of interest or significant to the table of 
Agility? More important, why should you learn about these different 
methodologies instead of simply focusing on one? There is no one shoe 
that fits all. Any methodology that requires you to follow it in 
totality and not let you adapt is rather dogmatic, not pragmatic. To be 
effective we have to take the best of different approaches and apply to 
our projects base on our specific needs. In this session, we will look 
at different methodologies that promote agility. We then will compare 
and contrast the features of each. You can take away from the 
presentation what makes the most sense for your project and team.

Session #43: Naked Objects Applied by Eitan Suez
Join Eitan in this hands-on session on Naked Objects. This session uses 
the "learning by doing" approach to learning an API or framework. Naked 
Objects is a powerful tool that can give you a significant advantage in 
the development of business systems. It gives you the ability to 
prototype a software application so quickly that it can be performed 
during information gathering phases of a project. It gives you the power 
to codevelop the core business model of your application with a 
non-developer business expert at your side. No prerequisite knowledge of 
Naked Objects is required.

Session #44: Working with Java Metadata (Java) by Ted Neward
As part of JDK 1.5, Java has introduced a facility for developers to 
create and use custom metadata annotations, as developed
by the JSR 175 committee. This represents a radical new shift for the 
Java programming language, quite possibly larger and farther-reaching 
than generics or any other language feature. In this talk, see the 
syntax and usage model for Java annotations, both how to create them as 
well as to use them in your code. We'll see different ways to find and 
consume the annotations declared on classes, including extensions made 
to the Java Reflection API as well as a new tool, "apt" (Annotation 
Processing Tool), for consuming annotations on source files. In 
addition, we'll discuss what annotations are best used for, and when 
they should be bypassed in favor of other approaches.

Session #45: J2EE Transaction Management: Techniques and Best Practices 
- Part II by Mark Richards
This session is the second part of a 3 hour transaction management 
session. In this session we will explore some of the more advanced 
features of J2EE transaction management. We will pick up where we left 
off from the first session by taking a detailed look at XA and J2EE 
distributed transaction processing, and how to coordinate multiple 
resources within a single business transaction. Within the XA discussion 
you will learn what XA is, what the relationship is between JTA and XA, 
when you should use XA within J2EE applications, and how to enable JMS 
and DBMS resources to run under XA. We will also explore XA Drivers, and 
discuss the many issues surrounding XA Drivers within J2EE. We will then 
look at several transaction strategy design patterns, and learn what the 
advantages and disadvantages are of these patterns and how to apply 
them. We will end this session with looking closer at the Local 
Transaction Model, where this model breaks down, and the steps involved 
in converting from a Local Transaction Model to a Declarative 
Transaction Model.

12:30 – 1:15 PM Lunch

1:15 – 2:15 PM Birds of a Feather Sessions

2:15 PM – 3:45 PM

Session #46: Prudent OO Design by Venkat Subramaniam
Is your code object-oriented? Developing with objects involves more than 
using languages like Java, C#, C++ or Smalltalk for that matter. From 
time to time, the OO paradigm stumps even expert developers. Agile 
programming becomes a mere act of hack if we code without knowing the OO 
principles. What are these principles – the ones that influence your 
design? In this presentation the speaker will present some of the 
challenges that are fundamental in nature. Then he will present OO 
Design principles and good practices for prudent development of OO code.

Session #47: Introduction to Web services, 2005 edition (Architecture) 
by Ted Neward
WSDL, and Schema and SOAP, oh my! It's 2005, and the Web services 
landscape looks even more confusing than it did two years ago, despite 
all sorts of promises to the contrary. What's it all mean, and how the 
heck did we get here when the original goal was to try and keep it all 
simple? In this talk, we'll go over the Web services landscape, examine 
the prominent and popular (SOAP, WSDL, Schema) specifications, look over 
the less well-known but important (WS-ReliableMessaging, WS-Addressing, 
and more) ones and talk about why they're important, and lay out a list 
of the losers (WS-Routing, WS-Referral) and why they haven't made the 
cut. When we're done, we'll examine them all in the harsh light of day 
and discuss which ones developers really need to care about, and which 
ones they can safely ignore, either for now or for good.

Session #48: The State Machine Compiler by Eitan Suez
Classes will often bear various states. Examples include a user who may 
be "logged in" or "logged out," a bill that is "open" or "paid," or
potentially a more complex situation where an object obeys a set of 
complex rules that determines which of a number of possible states that
object is in. The Gang of Four gave us the State Pattern, a fairly 
straight-forward mechanism for developers to model and implement the
behaviour of stateful objects. The State Pattern is only the beginning 
of the story. Robert Martin developed the State Machine Compiler and
has taken the job of developing and maintaining stateful systems to a 
new level. Today, SMC is a well-maintained open source project hosted
on sourceforge.net. Come learn about SMC, a fundamental tool for 
implementing stateful classes and systems that every software developer
should have in his toolchest.

Session #49: Groovy by Dion Almaer
Groovy is an agile, dynamic programming language for the Java Virtual 
Machine. Groovy includes language features found in Python, Ruby, and 
Smalltalk, but uses syntax natural to developers that use the Java 
programming language. Because Groovy is based on Java 2, applications 
written in Groovy can use the full complement of Java 2 APIs, and work 
seamlessly with other packages and applications written in the Java 
programming language. The Groovy JSR will make the Groovy the next 
standardized programming language for the Java Virtual Machine. This 
tutorial introduces you to Groovy programming language and explains how 
it in to solve a variety of problems.

Session #50: Hibernate and J2EE Transaction Integration by Mark Richards
Hibernate is quickly becoming a viable alternative to the EJB Entity 
Bean and DAO persistence models. More and more applications are being 
written using Hibernate, and many existing applications are replacing 
legacy Entity Bean or DAO persistence models with Hibernate. Hibernate 
has it's own transaction manager and transaction API that is simple to 
configure and use for single resource, web-based applications. However, 
things get a bit more complicated from a transaction standpoint when you 
consider using Hibernate as the persistence model for larger 
server-based J2EE Enterprise Applications. In this session we will take 
a look at how the Hibernate transaction model works and how to integrate 
Hibernate into the JTA transaction model within J2EE. We will look at 
both single resource coordination and multiple resource coordination, 
and how to manage transactions outside the scope of Hibernate. During 
this session you will learn the details of the Hibernate transaction 
model and how to integrate Hibernate into J2EE with both a single 
resource and multiple resources using XA. We will look at integrating 
Hibernate into J2EE applications using three J2EE transaction strategy 
design patterns; the Client Transaction Control pattern, Server Delegate 
Transaction Control pattern, and Service Transaction Control pattern. By 
the end of this session you will learn how to develop a robust global 
JTA transaction design strategy for large-scale J2EE applications using 
Hibernate as the persistence model for database resources.

3:45 – 4:00 PM Break

4:00 - 5:30 PM

Session #51: The good, bad and ugly of Java Generics by Venkat Subramaniam
Java introduced Generics in the 1.5 version (Java 5). What are the 
capabilities of Generics? How do you use it? Are there some gotchas in 
using it? In this example driven presentation, we will start at the 
basics of generics and look at its capabilities. We will then look at 
some of the under the hood details on generics implementation. We will 
then delve into the details of some of the changes to Java libraries to 
accommodate generics. Finally we will take a look at some restrictions 
and pitfalls that we need to be familiar with when it comes to practical 
and prudent use of generics.

Session #52: Business Rules Engines in Java and J2EE- An Introduction to 
the Drools Rules Engine by Brian Sam-Bodden
Software development is expensive, when business rules are hard-coded in 
your application’s source code, changes and additions to those rules 
translate to wasted time and money. Good object-oriented, 
component-based approaches can alleviate the burden of keeping up with 
changes in the business world but they still require that expert 
knowledge of the changes be passed from the decision makers to the 
business analysts and finally to programmers that need to implement 
these changes. Business Rule Engines and Business Rule Languages are 
based on the basic premise of separation of concerns by empowering 
business domain experts to express the rules of business in a way that 
it is directly usable by applications.

Drools is an open source pure-Java implementation of a forward chaining 
rules engine. Drools can be used in a J2SE or J2EE application and 
allows you to express rules in a variety of scripting languages, 
including Python, Groovy and Java. Learn how Business Rules with Drools 
can make your Java applications more flexible and robust.

Session #53: Enterprise Java Architecture – Open Forum with Ted Neward
Bring all of your questions and insight regarding Enterprise Java 
Architecture to this open forum discussion hosted by Ted Neward.

Session #54: XML Data Binding with JiBX by Eitan Suez
JiBX is an open source XML data binding API for Java. JiBX is younger 
than most other APIs in this space (Castor XML, BEA XMLBeans, JAXB). 
JiBX's philosophy on data binding is that: [a] databinding should be 
fast, and [b] databinding frameworks should allow for the divergence and 
evolution of your codebase from its xml representation. JiBX excels on 
both counts and consequently is a practical tool for the purpose of data 
binding. In this session, Eitan will be covering all aspects of Dennis 
Sosnoski's JiBX framework.

Session #55: A Pragmatic Look at Agile Architecture by Mark Richards
Designing application and enterprise architectures is a complex process. 
We follow defined processes, create lots of attractive architecture 
diagrams, kill lots of trees producing hundreds of pages of architecture 
documentation, and yet we find that in many cases the architectures we 
design are not followed by developers or simply not understood by the 
stakeholders or development community. As a result, either the delivered 
software does not match the original architecture, or the architect 
works 25 hours a day to ensure that the software is in compliance with 
the original architecture. We will then look at some Agile principles 
and see how we can apply these methods to simplify the architecture 
process and produce better architectures. We will also look at some 
pragmatic techniques for architecture design and diagramming that 
support Agile Architecture, and learn how ATAM (Architecture Trade-off 
Analysis Method) can be applied to the concept of Agile Architecture. Of 
course, no pragmatic session would be complete without a discussion of 
the issues and shortcomings of the Agile Architecture process itself, so 
we will explore where the Agile Architecture process sometimes fails to 
live up to its promise.