[GR-Jug]
JUG Discount Still Available... Don't Miss Out... Join Us for the
Michigan Java Software Symposium coming to Detroit on October
18-19th
Jay Zimmerman
jzimmerman at completeprogrammer.net
Fri Oct 10 02:17:09 EDT 2003
Michigan Java Software Symposium
October 18 -19, 2003
A “No Fluff, Just Stuff” Conference
www.nofluffjuststuff.com <http://www.nofluffjuststuff.com/>
Westin Detroit Metropolitan Airport
The No Fluff Just Stuff Java Symposium Tour cordially invites you to
register for the Michigan Java Software Symposium. This three day Java
conference will be offered in Detroit, TX on October 18-19, 2003. MJSS 2003
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 Michigan Java Software Symposium will feature over forty high quality
technical presentations and an expert panel discussion and
point/counterpoint sessions. In addition, some of the speakers are:
* Ted Neward, author of the soon to be released “Effective
Enterprise Java”
* Bruce Tate, author of the best seller, “Bitter Java” and “Bitter
EJB”
* Stuart Halloway, author of “Component Development for the Java
Platform”
* Maciej Zawadzki, co-author of the soon to be released “Java
Development with Extreme Tools, II”
* Venkat Subramaniam, President of Agile Developer
* Craig Walls, co-author of “XDoclet in Action”
* Dennis Sosnoski, Developerworks contributor
The Top 5 Reasons to attend the Michigan Java Software Symposium:
1). MJSS 2003 has a limited attendance of 200 people. We do this to
insure a great deal of interaction between speakers and attendees.
2). MJSS 2003 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 MJSS 2003 allows companies to send entire software
development teams because of price, location and timing (held over a long
weekend).
Registration/Pricing Information:
The registration fee for MJSS 2003 is $695/attendee. For JUG members there
is a $100 discount available. Use the discount code, “595jugmjss”.
The registration fee includes admission to the symposium, symposium CD with
all presentation content, handouts for each session attended and all
meals/snacks.
There are excellent discounts available for software development teams:
5-9 Attendees: $545/person
10-14 Attendees: $495/person
15-24 Attendees: $450/person
25-over Attendees: $425/person (Includes a free book from one of our
author/speakers & NFJS T-Shirt)
Want to Know More? Questions?
Michigan Java Software Symposium:
www.nofluffjuststuff.com/2003-08-detroit/index.jsp
Contact: Jay Zimmerman, jzimmerman at nofluffjuststuff.com
<mailto:jzimmerman at completeprogrammer.net> , (303)469-0486
Michigan Java Software Symposium
-Session Schedule-
October 18, 2003
7:30 – 8:30 AM: Registration & Continental Breakfast
8:30 – 8:45 AM: Welcome/Overview
8:45 – 10:15 AM:
Session #1: Class Loading by Stuart Halloway
Java's class loader architecture provides a dynamic and extensible mechanism
for building applications. You will learn how to use class loaders to deploy
multiple versions of classes side-by-side in the same JVM, and how to
redeploy components without shutting down servers. You will also learn how
to troubleshoot class loading problems such as inversion. You will learn to
use the context class loader to correctly implement factory methods, and how
to load non-code resources.
You will also see the problems that J2EE and other container environments
pose to the standard class loading architecture. You will
see that the "solutions" to these problems (the endorsed standards override
mechanism and non-delegating class loaders) cause as many problems as they
solve, and learn to work around the wrinkles that these non-solutions.
Session #2: Enterprise Java: Principles by Ted Neward
>From the book of the same name, this talk investigates the core principles
that a Java developer or architect must keep in mind when designing,
implementing and maintaining an enterprise Java system.
Session #3: XML the Easy Way(s) by Dennis Sosnoski
XML is becoming more and more a part of everyday programming. Fortunately,
there are now tools available that simplify working with XML and avoid much
of the pain experienced by early adopters. In this session you'll learn
about the three main types of XML APIs - parsers, document models, and data
bindings - with a focus on the latest developments that make XML handling
easier than ever before. You'll also find out the pros and cons of each type
of API, including performance and memory footprint comparisons, and see
examples of actual usage through extensive sample code. Find out how to pick
the right API for your application and simplify your XML programming!
Session #4: Java Persistence Frameworks by Bruce Tate
When your application is too complex for pure JDBC, you need to consider
persistence frameworks, but the choices are daunting. Learn what makes a
good persistence framework. Learn some of the common pitfalls around data
persistence, and what add-ons are important for delivering good performance.
You’ll first learn about the principles of persistence frameworks. Then,
you’ll be able to compare and contrast the many Java persistence solutions,
including in-depth discussions with Hibernate and JDO code examples.
10:15 – 10:30 AM Break
10:30 – 12:00 PM
Session #5: Struts 1.1 by Cobbie Behrend
Struts has quickly become the most widely used java server side model view
controller framework. This talk will introduce you to the basic concepts of
Struts as well as some features that are new to the 1.1 version of Struts
such as Modules, DynaActionForms, and the Validator Framework. This session
is recommended for those who are either new to Struts or the latest 1.1
release.
Session #6: Effective Enterprise Java - Systems by Ted Neward
In the style of works of the same title, "Effective Enterprise Java" lays
out a number of items that offer practical, far-reaching advice about how to
build systems using J2EE. In this talk, we will go over a number of the
items in the "System" chapter, focusing on items that center around the JVM
itself and its platform infrastructure. Items like "Use the right JVM", "Use
independent JREs for side-by-side versioning" and "Recognize ClassLoader
boundaries" will give attendees the necessary tools to start improving their
J2EE applications without ever having to change a line of code.
Session #7: Reflection by Stuart Halloway
One of Java's most important platform services is rich type information.
You will learn how to access type information through reflection, and
leverage type information to generate persistent formats, data access code,
and XML data bindings. You will learn how to use reflective construction to
implement factory methods, and how to use reflective invocation to simulate
function pointers. You will also explore the security implications of
reflection and how these are managed.
Session #8: JDO Compare/Contrast by Bruce Tate
In this session, we’ll learn about what’s good and bad about JDO, compared
to other persistence frameworks like Hibernate and EJB. We’ll also learn
about how the JCP committee is hoping to improve the next iteration of JDO.
If you’re already a JDO expert, this session is not for you, but if you are
deciding about how well JDO might fit into your environment, this is the
ideal session for you.
12:00 – 12:45 PM: Lunch
12:45 – 1:45 PM: Expert Panel Discussion featuring:
Ted Neward, author of the soon to be released “Effective Enterprise
Architecture”
Stuart Halloway, author of “Component Development with the Java Platform”
Bruce Tate, author of “Bitter Java” & “Bitter EJB”
Maciej Zawadzki, co-author of the soon to be released “Java Development with
Extreme Tools, II”
Craig Walls, co-author of the soon to be released “XDoclet in Action”
Venkat Subramaniam, President of Agile Developer, Inc.
Dennis Sosnoski, President of Sosnoski Software, Inc.
Mike Burba, Product Manager with Compuware, Inc.
1:45 – 3:15 PM
Session #9: Introduction to XDoclet by Craig Walls
If you are developing J2EE applications, you need to be using XDoclet. This
powerful tool not only saves time and unnecessary duplication, but can also
reduce hard-to-find errors. This session explains what XDoclet is, why it
was created, and how to use it for J2EE development. Specifically, XDoclet
generates web, EJB, tag library, and vendor-specific XML deployment
descriptors as well as EJB Java interfaces, and these aspects are covered in
this session using interactive live demonstrations.
Session #10: Model-Driven Developers do it faster! By Mike Burba
The Middleware company recently conducted a productivity study that compared
model-driven, pattern-based development with traditional development
techniques. The study concluded that model-driven development is 35% faster
than traditional techniques. Salil Deshpande, the CEO of TMC, called the
results "staggering", and Owen Taylor, a leading J2EE trainer and lead for
the traditional development team, said that he had a "new respect for MDA".
This session will give an overview of the study, then get into the details
of model-driven, pattern-based development. Included will be a look at some
model-driven, pattern-based tools to give the audience an opportunity to see
MDA in action.
Session #11: 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.
Session #12: Hibernate Overview by Bruce Tate
Hibernate is a popular new persistence framework. It allows transparent
persistence. It's based on reflection, so there's no byte-code enhancement.
Best of all, it's an OpenSource technology, so the price can't be beat.
Learn the basics about Hibernate. In this session, we'll learn about how
Hibernate works, and look at some mappings and code.
3:15 – 3:30 PM Break
3:30 – 5:00 PM
Session #13: Effective Enterprise Java: Concurrency by Ted Neward
>From the book of the same name, this talk examines the consequences of using
concurrency-control mechanisms (most notably Java synchronization blocks and
database-style transactions), and how to build a system that will continue
to scale in the face of contention.
Session #14: Applied Web Services by Dennis Sosnoski
SOAP-based Web services are taking over in the enterprise environment as a
practical way of linking business systems. Despite the ever-growing
popularity, there are still many problems in using Web services for
real-world applications. In this intermediate session you'll find out about
the main problem areas and the best ways to avoid them. The specific topics
covered include security (SSL and WS-Security), interoperability (encoding
issues, WS-I Basic Profile), and finally performance (SwA and DIME
attachments, custom SOAP interfaces). The presentation assumes you already
know the basics of SOAP and WSDL and builds from there. If you're working
Web services, come learn about the potholes in "the road ahead" before you
run into them head-on!
Session #15: Programming with XSLT by Venkat Subramaniam
Transforming an XML document using XSLT provides several advantages.
However, it is not some thing that is too easy to begin with. This
presentation is intended to demystify programming with XSLT. The speaker
presents easy to understand analogies between XSLT and notions most of us
are very familiar with. He then presents a quick over view of XPath notation
and shows how to perform transformations and effectively render the contents
of an XML document.
Session #16: Bitter EJB - Common programming traps with EJB by Bruce Tate
Bitter EJB is another Java antipatterns book from the author of Bitter Java,
and three new Manning authors. In this session, we’ll look at some EJB
examples, and discover some basic EJB pitfalls. We’ll then discuss remedies.
We’ll look at session beans, stateful session beans, EJB CMP, persistence
alternatives, and messaging antipatterns. We’ll have plenty of code
examples, from the book Bitter EJB. Note: This is a 3 hour session.
5:00 – 5:15 PM: Break
5:15 – 6:45 PM
Session #17: Challenging J2EE Assumptions: Developing EJB applications that
are simple and maintainable by Maciej Zawadzki
The EJB programming model as well as common J2EE design patterns such as the
Value Object Pattern impose a non Object Oriented structure on the resulting
applications. This lack of Object Oriented structure exists because:
Relationships between business objects (represented by EJBs) are not modeled
as object relationships but as foreign keys, and Coarse grained
ValueObjects are great for performance but are in effect simple data
structures that lack the behavior commonly associated with Objects. This
seminar will introduce the Domain Façade pattern that solves the
above-mentioned problems without sacrificing any performance or compliance
with the specifications. J2EE applications developed with the Domain Façade
pattern adhere more closely to Object Oriented Principles and are therefore
easier to develop, understand, and maintain. Numerous source code examples
will be provided.
Session #18: Learning Tests by Stuart Halloway
This talk will teach you to use unit testing for learning and validating
other people's code. You can use learning tests to teach yourself how to use
a new API, and simultaneously validate that the API meets your needs.
Learning tests is very similar to test-driven development. With TDD, you
write tests that fail, then develop your code to make the tests pass. With
learning tests, you learn a new API by writing tests that prove the API
works. No more wading through erroneous JavaDocs! What could be more fun?
In a short 90 minutes, you will learn a new Java API, learn JUnit, and learn
a new approach to learning Java.
Session #19: JAXB & JiBX XML Data Binding by Dennis Sosnoski
Data binding is the easiest way to handle most common usages of XML in Java
applications. It allows you to seamlessly and transparently convert between
XML documents and internal data structures without writing a lot of
processing code. In this session you'll learn about a pair of complementary
data binding frameworks. The JAXB Java standard gives direct generation of
code from W3C XML Schema definitions, with full validation, a wide range of
structure options, and interoperability between implementations. The open
source JiBX framework takes a
different approach, using mapping definitions constructed by hand or
generated from XDoclet notations in source files to construct a binding
between existing classes and XML documents. Each approach has major
advantages for certain types of applications, so knowing the benefits
and limitations of each will let you choose the best approach to suit your
needs! This session includes some quick coverage of XML Schema concepts, but
otherwise assumes an intermediate level of experience with both XML and
Java.
Session #20: Bitter EJB (Continued) by Bruce Tate
October 19, 2003
7:00– 8:00 AM: Continental Breakfast
8:00 – 9:30 AM
Session #21: Getting More Out of Your Struts by Cobbie Behrend
Struts is by no means the only MVC framework on the block. Frameworks such
as WebWork have some good criticisms of Struts. In this talk we will explore
some best practices for using Struts that address some of those criticisms.
While several general best practices will be covered, special attention will
be given to making Struts code more testable by decoupling it from J2EE
specific classes and your data tier.
Session #22: 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.
Session #23: Dynamic Java by Dennis Sosnoski
The virtual machine design at the core of Java gives developers access to
programming techniques much more flexible and dynamic than permitted by
statically-compiled languages. In this intermediate to advanced session
you'll find out about some of these Java features, starting with a quick
look at class structure and JVM operation, then moving on into the details
of using reflection for runtime access to class data and methods. Finally
you'll learn about framework techniques for modifying compiled class files
to add tracking information or special code hooks using the Javassist
library recently merged into JBoss, and even get a quick look at building
new runtime classes through direct byte code generation using the Apache
BCEL library. Find out about the dynamics of Java and stir things up in your
programming!
Session #24: JDO vs. EJB by Bruce Tate
Recently, EJB entity beans with container-managed persistence have come
under fire. Though EJB 2.0 and 2.1 make some much-needed improvements, they
may not go far enough. JDO can be an attractive persistence alternative for
some applications. Learn why in this session. We’ll compare code examples
for each, and look beyond technical issues to understand the strengths and
weaknesses of each We’ll leave the politics out of this discussion, and
focus on the technical issues.
9:30 – 9:45 AM Break
9:45 – 11:15 AM
Session #25: Ant Primer by Craig Walls
As the de facto standard build tool, all Java developers should have a
working knowledge of its capabilities, syntax, and best practices. This
session gently introduces you to Ant. A complete Java project will be
developed interactively, leaving you with the ability to be immediately
effective at using Ant for your next project!
Session #26: XML Schema for Java programmers by Stuart Halloway (Continued)
Session #27: JSR 175 - Custom Metadata for Java by Ted Neward
One of the most important JSRs in the JDK 1.5 release (and, arguably, in
Java's history) is the Metadata specification, JSR 175, which will permit
Java library developers to define "attributes", bits of Java code that can
be annotated to just about any part of the Java programming model--classes,
packages, methods, fields, and so on. In this talk, hear what the JSR
covers--and what it doesn't cover--along with syntax and usage model from
one of the members of the Expert Group working to define it.
Session #28: Better, faster, simpler Java by Bruce Tate
Over the past five years, notable Java frameworks like J2EE and EJB, have
become dramatically more complex. In this session, we’ll explore a set of
principles for bucking this trend, and some frameworks that use these
trends. Hibernate is a persistence framework that uses these principles very
well, and as a result, the popularity is growing rapidly. Spring, a much
younger framework, is an elegant container that is also starting to pick up
steam. We’ll then look at how you can use these ideas to build more
effective, faster, simpler applications of your own.
11:15 – 11:30 AM Break
11:30 – 1:00 PM
Session #29: 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.
Session #30: XDoclet Beyond J2EE by Craig Walls
You may know that XDoclet can save you a lot of time and headaches with
EJBs, Servlets, and JSP tag libararies. But did you know that there's more
to XDoclet than J2EE? In addition to the better-known EJB and Servlet
related tasks, XDoclet also comes with a rich set of code generation tasks
for several non-J2EE technologies. In this session, we'll explore these
non-J2EE applications of XDoclet, including how XDoclet can be used with
Hibernate, Apache Axis, JMX, and MockObjects.
Session #31: Code Generation: A Patterns Based Approach by Maciej Zawadzki
Code generation presents an opportunity for development teams to speed up
the development cycle, reduce the size of the effort, ensure consistent
quality, and provide more consistent role separation. This seminar will
provide an introduction to code generation technologies and practices. It
will start by explaining what is code generation (especially pattern based
code generation), and then it will cover why, when and how it should be
practiced. Along the way, this seminar will illustrate the use of
higher-level abstractions such as patterns to develop low-level code. A
process for developing higher-level languages used in code generation will
be presented in light of code generation environments.
Session #32: Database Performance 101 for Java Developers by Bruce Tate
As programmers need to learn more and more about advanced frameworks and
programming techniques, sometimes we lose sight of basic foundational tools
and techniques. With the recent backlash against EJB entity beans, more
people are using JDBC with basic SQL than ever before. Plain old relational
databases are old hat, but effectively using your RDBMS gives you the best
shot at good application performance. We'll learn how to read an access
plan, how to effectively partition a data model, how to design an effective
index and how to recognize and write efficient SQL.
1:00 – 2:00 PM Lunch
2:00 – 3:30 PM
Session #33: Put Your UI on a Diet with Thinlets by Craig Walls
Many of us flocked to Java early on because of Applets and Swing, but moved
to server-side development as we became disenchanted with the limitations of
AWT and the performance of Swing. The thought of UI development in Java
rarely crosses our minds and mere mention of the word "Applet" makes us
shudder.
What if I told you there was reason to be excited about Java UI development
again? What if I told you there was a reason to be excited about applets
again? This session will introduce Thinlets, a Java and XML based UI
framework for developing "really thin clients". Thinlets make it possible to
develop UIs richer than AWT, but without the performance or download
overhead of Swing. Furthermore, Thinlets can run on a Java 1.1 JVM, the
default JVM in most browsers. And, unlike AWT or Swing, Thinlets enforce
separation of presentation from business logic.
Session #34: J2EE vs. .net by Ted Neward & 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.
Session #35: 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.
Session #36: Struts 1.1 by Cobbie Behrend
Struts has quickly become the most widely used java server side model view
controller framework. This talk will introduce you to the basic concepts of
Struts as well as some features that are new to the 1.1 version of Struts
such as Modules, DynaActionForms, and the Validator Framework. This session
is recommended for those who are either new to Struts or the latest 1.1
release.
3:30 – 3:45 PM Break
3:45 – 5:15 PM
Session #37: EEJ: Architecture by Ted Neward
In the style of works of the same title, "Effective Enterprise Java" lays
out a number of items that offer practical, far-reaching advice about how to
build systems using J2EE. In this talk, we will go over a number of the
items in the "Architecture" chapter, focusing on higher-level discussions
like "Avoid round trips", "Understand what middleware actually does", and
"Optimize optimally". Discussion will center on what each of these means in
practical terms for the J2EE community, and why current systems don't do
this already.
Session #38: Real World Practices For Object Reuse by Maciej Zawadzki
Object Reuse has long been the elusive holy grail of software development.
Some are even beginning to question its existence. But this seminar will
reveal two production examples of successful large-scale object reuse and
provide a road map for others to follow. A capability/maturity model for
object reuse will be presented along with examples of practices typically
found at each maturity level. The role of practices such as software
configuration management (SCM), build management, dependency tracking,
branching, and refactoring will be presented. This seminar will conclude
with an examination how object reuse was successfully put into practice at
two companies (Alamo and FedEx Custom Critical).
Session #39: Advances in Web Services by Venkat Subramaniam (Continued)
Session #40: Managing WSDL with AXIS by Stuart Halloway
The Web Services Description Language (WSDL) can be a hostile environment,
especially if you are used to more Java-friendly remoting technologies such
as RMI. But WSDL is the backbone of Web Services as they exist today, so you
have to find a way to approach it.
Apache AXIS provides tools for managing WSDL. WSDL2Java builds Java
interfaces, implementations, and even test cases from a WSDL document. More
interestingly, Java2WSDL can generate WSDL from your existing Java classes.
Unfortunately, starting from Java will not always guarantee interoperable
Web services. Sooner or later, WSDL must take top billing. However,
starting from Java and experimenting with Java2WSDL's settings is a gentle
way to introduce WSDL, without having to assemble an entire WSDL document
from scratch.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://gr-jug.org/pipermail/jug/attachments/20031010/8bb49789/attachment-0001.htm
More information about the Jug
mailing list