Jay
Thanks for posting this. It looks like a great event.

--- In dvbug@yahoogroups.com, "Jay Zimmerman" <jzimmerman@b...> wrote:
> Java Freedom Software Symposium
> February 20-22, 2004
>
> A "No Fluff, Just Stuff" Conference
>
> www.nofluffjuststuff.com
>
>
>
> The No Fluff Just Stuff Java Symposium Tour cordially invites you to
register for the Java Freedom Software Symposium. This three day Java
conference will be offered in Philadelphia, PA on February 20-22,
2004. JFSS 2004 is designed for Java developers, Java Architects, and
technical managers who are looking for further insights on the J2EE,
XML, Web Services, Best Practices and Open Source.
>
>
>
> The Java Freedom Software Symposium will feature over thirty high
quality technical presentations and three expert panel discussions.
In addition, some of the speakers are:
>
>
>
> I). Robert Martin, author of "Agile Software Development"
> II). Craig Walls, co-author of "XDoclet in Action"
> III). Stuart Halloway, author of "Component Development for the
Java Platform"
> IV). Dave Thomas, author of "The Pragmatic Programmer"
> V). David Geary, author of "Core JSF" and "Core JSTL"
> VI). Mike Clark, co-author of "Bitter EJB"
> VII). Bruce Tate, author of "Bitter Java" and "Bitter EJB
>
> The Top 5 Reasons to attend the Java Freedom Software Symposium:
>
>
>
> 1). JFSS 2004 has a limited attendance of 200 people. We do
this to insure a great deal of interaction between speakers and
attendees.
>
> 2). JFSS 2004 presentations are content rich. You will come
away with new insights/knowledge that you can immediately apply in
your development environment.
>
> 3). High quality speakers who have tremendous technical
depth, practical experience and the requisite knowledge transfer
skills to be an excellent speaker.
>
> 4). The best value in terms of dollars/time ratio of any Java
based conference currently offered.
>
> 5). The format of JFSS 2004 allows companies to send entire
software development teams because of price, location and timing (held
over a long weekend).
>
>
>
> Registration/Pricing Information:
>
> The early bird registration (good thru 2/02/04) is $625/attendee.
There is a special discount of $50 available to all DVBUG members
valid thru 2/2/04(Final Price is $575/person). Please use the
discount code "jfssjug575". After 1/26/04, the registration fee will
be $725/person.
>
>
>
> The registration fee for the Java Freedom Software Symposium
includes:
>
> · Admission to the symposium
>
> · Symposium CD with all presentation content
>
> · Handouts for each session attended
>
> · All meals/snacks
>
>
>
> There are excellent discounts available for software development
teams:
>
>
>
> 5-9 Attendees: $550/person
>
> 10-14 Attendees: $525/person
>
> 15-24 Attendees: $495/person
>
> 25-over Attendees: $450/person
>
>
>
> Want to Know More? Questions?
>
> Java Freedom Software Symposium:
www.nofluffjuststuff.com/2004-02-philly/index.jsp
>
> Contact: Jay Zimmerman, jzimmerman@n..., (303)469-0486
>
>
>
>
>
>
**************************************************
**************************************************
**************************************************
********************************************
>
> 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:
>
> a.. When should I catch an exception versus declare that a method
throw it?
> b.. How do I safely close database connections and I/O streams?
> c.. When should I use application-defined exceptions?
> d.. Should a method I write ever declare "throws SQLException"?
> e.. 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:
>
> a.. Why Use Patterns?
> b.. What is an Adapter?
> c.. Adapting Existing Objects into Submission
> d.. What is a Decorator?
> e.. Decorating Existing Objects to Enhance their Behavior
> f.. 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:
>
> a.. Movie Scripts, Roles and the Casting Director
> b.. The Many Levels of Roles in an Application
> c.. Coupling via Interfaces
> d.. Implementation and "Inheritance vs. Composition"
> e.. Using Proxies, Decorators, Adapters, Factories and Façades
During Implementation
> a.. 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.