Java Freedom Software Symposium

Draft – Session Listing (More Sessions to come…)

-February 20-22, 2004-

Continuous Performance Testing by Mike Clark

Tuning J2EE 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 common pitfalls related to the J2EE performance tuning process.  We'll sacrifice an application with undesirable response time and scalability as a crash test dummy for performance testing. Then we'll tune it 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. Along the way we'll explore testing tools including JUnitPerf and JMeter.  As a result of attending this session you'll be able tune J2EE 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.

Clean and Green by Mike Clark

As programmers, code is our artist medium.  Code can be beautiful or downright ugly.  But aside from aesthetics, clean code that passes all its tests is generally easier to maintain and extend.  We'd all like to think we write pristine code at all times, but as the size of the code base grows and we're under pressure to deliver new features, code rot often times sneaks up on us.

In this session we'll look at a goodly amount of code to learn how to identify code smells before they begin to rot.  We'll practice safe and economical refactoring techniques to keep the code clean and green in the face of change.  We'll also look at how to use popular IDEs for automating well-known refactorings.

Staying FIT by Mike Clark

FIT is a framework for acceptance testing that fosters healthy cooperation between customers, testers, and developers.  When FIT tests are run inside of a wiki, such as FitNesse, you enjoy the benefits of a collaborative testing and documentation environment.  Indeed, you can easily define new acceptance tests and run them all at the push of a button in the browser.

In this session you'll learn how to use FIT and Fitnesse by writing FIT test fixtures in Java, defining test input and expected outputs using

the FitNesse wiki, and continually running all the tests to measure the health of your system.

RELAX NG and JDOM: Simpler, Easier Java/XML Technologies by Ben Galbraith

Does working with the W3C XML Schema language and/or Java's JAXP XML API (based on the W3C DOM API) give you a headache?  It doesn't have to be that way.  This session will explore two technologies designed to make XML easy.  The first, RELAX NG, is a mature, standardized XML schema language that counts ease of use and flexibility as its key features. As an added bonus, it is in many ways technically superior to W3C XML Schema language.  If you're currently working with DTD or W3C XML Schema to design your XML documents, come see how your life can be made much easier and how you can use RELAX NG in your Java applications today. The second technology, JDOM, is a dramatically easier API than JAXP for parsing XML in a tree-like structure.  If you're using the JAXP to parse XML into DOM trees, put yourself out of your misery and come learn a better way.

Alternatives to Swing by Ben Galbraith

For various reasons, many developers find Sun' Swing GUI toolkit unsatisfactory (performance and ease-of-use issues being top among them).  When IBM released their Standard Windowing Toolkit (SWT), a new excitement rippled through the community with the emerge of at least one viable alternative.  In fact, there are several other alternatives to Swing, including Thinlet, wx4j, and XUL-based frameworks.  This session will examine these alternative GUI toolkits, demonstrating their look-and-feel, performance, and most importantly, APIs.  However, before developers jump off the Swing ship, they should know that many tools exist to make Swing development easier and Swing applications better. We'll take a look a several of these, including the SwingWorker class and the FoxTrot project.

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. JavaServer Faces Advanced Topics

JavaServer Faces Advanced Topics by David Geary

This session picks up where JavaServer Faces Fundamentals left off,  with a look at these advanced JSF topics: the data grid component, JSF  and Tiles, supporting cell phone clients, and implementing custom  components and renderers.  This session shows you how to use JSF's most intricate component, the  data table. You'll learn all the data table tricks of the trade, such  as scrolling through data and showing and hiding table columns. This  session also illustrates supporting alternate display technologies--cell phones, to be exact with a battleship application  that runs in a web browser and on a cell phone. Finally, this session looks at implementing your own custom components and renderers when  JSF's default set is not enough for your needs.

eXtreme Struts by David Geary
Struts is a popular Java-based web application framework and eXtreme  Programming (XP) is a powerful software methodology popular among Java  developers. Together, Struts and XP represent a formidable framework for developing flexible, robust, and reliable web applications. Come  see how to practice eXtreme Struts, which combines Struts and other open-source frameworks and development tools, such as: Ant, WebDoclet,  JUnit, Cactus, Struts Test Case, Tiles, the Commons Digester and  AspectJ.  Besides illustrating how you can use Struts with other open-source 
software, this session also discusses advanced Struts topics such as Tiles, Dynabeans, and the Validator. This two-pronged strategy, using  Struts advanced features with other open-source software, shows you how to be as productive and efficent as possible while developing  bullet-proof web applications.

Rapid User Interface Development with Tiles by David Geary
One of the jewels buried in Struts 1.1 is Tiles: a set of JSP tags that  let you construct user interfaces from individual JSP pages known as  tiles. Tiles facilitate very flexible user interfaces; tiles can contain other tiles and you can extend existing tiles to create new ones. Tiles makes it easy to share layout among pages, and perhaps more importantly, makes global (or local) layout changes easy to apply.  If you develop J2EE user interfaces, Tiles is, pound-for-pound, one of  the best single additions you can make to your J2EE toolchest. You'll be able to create user interfaces more quickly and easily adapt to changes that would otherwise throw monkey wrenches into tile-less code.  Although Tiles is distributed with Struts 1.1, it can be used standalone or with other web application frameworks such as JavaServer Faces (JSF). This session illustrates using Tiles with JSP, Struts, and  JSF.

Exploring 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.

Metaprogramming: Making Patterns Better by Stuart Halloway
Metaprogramming is writing code that manipulates code (possibly itself). All good programmers need to be familiar with metaprogramming
techniques. Metaprogramming  simplifies many common design patterns to the point of triviality, allowing us to move our concentration to more
important issues.  The need for metaprogramming is driven by the 'Don't Repeat Yourself' (DRY) principle. With metaprogramming, you can greatly reduce some of the repetitive aspects of software development, producing code that is better factored and more precise. This is a practical, 'Show me the code' presentation. I will present a series of working code examples from real projects. I found all of the examples listed by running 'grep' on my own source code and the published library source code for the languages I use.

Metaprogramming Examples
------------------------
Simulating function pointers
Loosening the interface contract
Decoupling: Better Observers
Minilanguages
Projection and injection: Better Iterators
Closures
Walking the call stack
Securing the call stack
Simple Interception
Intercepting New: Better Factories
Intercepting New: Better Singletons
Code Generation: Choosing the right tools

Class Loading in Java: Building Dynamic Systems Without Pain by Stuart Halloway

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.

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.

XML Schema for Java programmers by Stuart Halloway

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

Scripting, that's Groovy! By Tom Janofsky

In this talk, we'll examine Groovy, the new high-level scripting language with features from Java, Python and Ruby, and take a look at the ways that developers can successfully integrate Groovy within their system architecture.

Rules Engines and You, Perfect Together by Tom Janofsky

Software developers struggle constantly with changing business rules and requirements. This talk will address the externalization of business logic from developed systems, focusing on the power of rules engines such as Jess and the open source "drools" engine.

Patterns for Exception Handling by Scott Stanchfield

Exception handling in Java may seem simple, but there are several concerns and potential problems:

• When should I catch an exception versus declare that a method throw it?
• How do I safely close database connections and I/O streams?
• When should I use application-defined exceptions?
• Should a method I write ever declare "throws SQLException"?
• Are checked exceptions "good", "bad", and/or "ugly"?

In this talk, we'll briefly discuss the basics of exception handling, and delve into the above concerns and more. We'll explore how to properly set up exception handling to ensure safety and flexibility in applications. We'll demonstrate common patterns and frameworks for making you effective in your error handling.

Adapter and Decorator Tweaking Objects for Fun and Profit by Scott Stanchfield
 So just how should you be using those design patterns you've heard so much about?

Adapter and Decorator are two of the most common patterns you'll find yourself using, or at least should be using. These patterns allow you to easily translate existing objects for new and amazing purposes, cutting out the drudgery and performance impacts of copying data from one structure to another.  After discussing the concepts behind these patterns, we'll bury ourselves in some Java code to find out just where, why, and how you would use them.  Topics Covered:

• Why Use Patterns?
• What is an Adapter?
• Adapting Existing Objects into Submission
• What is a Decorator?
• Decorating Existing Objects to Enhance their Behavior
• Why Not "Just" Call Them Both Adapter?

Effective Interfaces by Scott Stanchfield

Java Interfaces tend to be greatly misunderstood and underutilized by programmers. Many programmers mistakenly believe that the "Interface" type exists solely as a replacement for multiple class inheritance. Interfaces are much more powerful and useful than that.  Applications are, or at least should be, composed of several components, working in concert to achieve certain goals. Each component plays one or more roles in the application. If you concentrate on the definition of these roles before implementing the components, you can prevent accidental implementation coupling and allow easier independent maintenance or replacement of components, even at runtime.

This session will begin by discussing the concept of roles in the real world, then mapping that concept to Java interfaces. We'll examine the types of problems that can be avoided through the "role" thought process, and demonstrate how concentrating on Java Interfaces before classes improves adaptable design. During this session, you'll see the benefits of delegation and composition over class inheritance, and learn why thinking "what" before "how" is so critical to a good design.

Topics Covered:

• Movie Scripts, Roles and the Casting Director
• The Many Levels of Roles in an Application
• Coupling via Interfaces
• Implementation and "Inheritance vs. Composition"
• Using Proxies, Decorators, Adapters, Factories and Façades During Implementation
  • Hint: Factories are your Friends

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.

Programming with Hibernate by Bruce Tate

Hibernate is the most exciting open source persistence framework that we’ve seen in quite some time. My introduction to Hibernate sessions saw attendance grow from 5 people to 50 over 2003, so this year, attendees should be hungry for more Hibernate depth. This is a programming talk. We’ll lead you through Hibernate programming, and then talk about some best practices.

EJB CMP, JDO and Hibernate: Compare and Contrast

Arguably, the three persistence frameworks with the most momentum are EJB CMP (we’ll use JBoss), JDO (we’ll use SolarMetric’s Kodo JDO), and Hibernate. In this session, you’ll explore what’s fundamentally different about each, and the special characteristics that each one brings to the table. You’ll see the overall architecture, the technique for Java integration, and understand the fundamental problem that each was built to solve.

J2EE Versus .net by Bruce Tate

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.

Java Persistence Frameworks by Bruce Tate

Working with a database from Java applications can be a frustrating and difficult task, and the number of choices can be frightening. Choose right, and you’ll improve your live immeasurably, by hiding tedious details from your application. Choose wrong, and you’ll wear a ball and chain that will drag down your performance, your productivity and even your projects. In this introductory talk, we’ll explore the basic problems related to object oriented persistence frameworks. We’ll also look briefly at three frameworks, and two strategies to build one yourself.

Better, faster, lighter Java

See the foundation for Bruce Tate’s newest book, scheduled to be published by O’Reilly this summer. In recent years, the complexity of typical Java applications has grown without bound. Frameworks like EJB often lead to bloated, invasive designs that are increasingly difficult to build and maintain. Learn to take a simpler, focused view of Java development, and understand how those techniques can make you a better programmer.

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.

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.

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.

Ruby for Java Programmers by Dave Thomas of the Pragmatic Programmers

Smalltalk was ahead of its time: we're just entering the decade of the untyped, flexible language. And by all accounts, Ruby could well be the language of that decade. Small, but tremendously expressive, Ruby is finding favor among all kinds of developers. From web applications to numerical simulations at NASA, Ruby is gaining popularity and mindshare.  In this overview for Java programmers, we'll look at some of the unique features of Ruby, and run some examples of Ruby code.  As a developer, you owe it to yourself to have a look at Ruby. Even if you never write a line of Ruby code, the ideas in the language can greatly improve the way you think about design and the ways you implement your programs. And if you do starting writing Ruby, you'll discover the tremendous productivity and readability gains that are possible.

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.

Advanced Version Control with CVS by Dave Thomas

We all know that we should be using version control, and many of us (perhaps as many as 50%) do use it on our projects. Yet few teams use

version control properly. They shy away from some of the more advanced features, perhaps because of the poor existing documentation, or perhaps because they've been on teams that tried them and sank under the complexity.

Wn this talk we'll cut though the complication. We'll show a number of advanced features of CVS, probably the most widely used version control system. We'll see how to handle things such as branching, merging changes between branches, submodules, and so on.  We'll look at these features from a practical perspective: we'll distill them into a series of recipes that developers can use every day on their projects.

XDoclet and J2EE By Craig Walls

Remote interfaces, home interfaces, and deployment descriptors—oh my! Developing J2EE applications requires you to write a lot of boilerplate code. When code is repetitive, code generation is a must. Come to this session and find out how XDoclet can take on the task of writing much of the tedious J2EE code for you.

What New with XDoclet 2?  By Craig Walls

There’s a new version of XDoclet in the works. This new version will be far more flexible and easier to extend than XDoclet 1.2. Both XDoclet rookies and veterans will benefit from attending this informative session where we will unveil the new features in XDoclet 2 and find out how XDoclet will change.

Taming Your Build Process: A Maven Primer by Craig Walls
As developers, we all like writing code. But do you really like writing code that supports your build? If you're finding that your Ant build files have more lines of code than many of your Java class files, then you should take a look at Maven. In this session, you'll learn how Maven abstracts away common Ant build tasks resulting in simple and more easily managed builds.