[GR-Jug] Early Bird Discount Ends this Friday, August 27th.. Join Us for the 2004 Michigan Java Software Symposium coming September 22-24th

[Jay Zimmerman]

Gateway Java Software SymposiumMichigan Java Software Symposium 2004
September 24-26, 2004

A "No Fluff, Just Stuff" Conference

Novi, MI

www.nofluffjuststuff.com/2004-09-detroit/index.jsp 

 

"The Best Value in the Java Conferencing Space Hands Down"

 

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 Novi, MI on September 24-26, 2004.  MJSS 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 Michigan Java Software Symposium will feature over forty high quality technical presentations and three expert panel discussions.  In addition, some of the speakers are:

 

·          Stuart Halloway, author of "Component Development for the Java Platform"

·          Bruce Tate, author of "Bitter Java" and "Better, Faster, Lighter Java"

·          Dave Thomas, author of "The Pragmatic Programmer"

·          Dennis Sosnoski, Developerworks Contributor

·          Ted Neward, author of "Effective Enterprise Java"

·          David Geary, author of "Core JSF" and "Core JSTL"

·          Ben Galbraith, author of "Professional JSP 2.0"

·          Mike Clark, author of "Pragmatic Automation"

 

 

 

The Top 5 Reasons to attend the Michigan Java Software Symposium:

 

1).        MJSS 2004 has a limited attendance of 200 people.  We do this to insure a great deal of interaction between speakers and attendees.

2).        MJSS 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 MJSS 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 8/27/04) is $625/attendee.  After 8/27/04, the registration fee will be $725/person.  

 

There is a $50 discount available to all JUG members thru 8/27/04.  Please use the discount code, "mjssjug575" when registering.

 

The registration fee for the Michigan Java 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 thru 8/27/04: 

 

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?

Lone Star Java Software Symposium: www.nofluffjuststuff.com/2004-09-detroit/index.jsp  

Contact: Jay Zimmerman, jzimmerman at nofluffjuststuff.com, (303)469-0486

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 24, 2004

12:00 - 1:00 PM: Registration 

 

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

 

1:15 - 2:45 PM: 

 

Session #1: 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.

 

Session #2: Java Classworking by Dennis Sosnoski

The Java binary class structure allows tools to easily manipulate classes generated from source code, and even generate completely new classes on the fly. This classworking ability provided by Java allows cross-cutting aspects of program operation to be implemented without touching source code. In this advanced session you'll get a quick look at class structure and JVM operation, then learn about framework techniques for modifying compiled class files and building new classes to meet your runtime needs. You'll get demonstrations of working with both the Javassist library that's now part of JBoss, and the Apache BCEL library, and find out the strengths and weaknesses of each. Classworking is a very powerful but specialized technique that's used mainly in developing tools and frameworks for developers, so to wrap up the session you'll get a look at a pair of classworking-based tools that can help in your day-to-day work.



Session #3: Better, faster, lighter Java by Bruce Tate

This session is a philosophical discussion based on the popular new book by Bruce Tate. Over the past five years, notable Java frameworks like Web Services and EJB, have become dramatically more complex. Other sessions from Bruce Tate explore Hibernate and Spring in detail, while this session tries to look at those projects as a model for building lightweight software. In this session, we'll look at forces that bloat Java. Next, we'll try to examine Spring and Hibernate, extracting core principles that will let you build simple, lightweight Java applications.

 

Session #4: 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.



2:45 - 3:00 PM Break 

 

3:00 - 4:30 PM

 

Session #5: Programming with Hibernate by Bruce Tate

Hibernate is an open source framework that supports transparent persistence. In this session, learn how to program a basic Hibernate application. Understand the code generation strategies for Hibernate, how to do a basic mapping, how to manage sessions, and some basic HQL. Also, see basic Spring integration.

 

Session #6: 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.

 

Session #7: Cleaning up SOAP by Dennis Sosnoski 

The Brave New World of Web services continues its forward march, with whole new crops of WS-* proposed specifications (and even a few that have been approved), new ways to improve interoperability (WS-I Basic Profile), and new interoperability problems (especially with attachments, where a certain software monopoly can't make up their mind what they're going to support). In part one of this two-part session you'll learn how SOAP has changed from a simple RPC technique (the rpc/encoded approach) to a wrapper around XML document exchange (the document/literal approach), and see how that change effects developers working with Web services in Java. You'll find out about different ways of implementing Web services using the JAX-RPC reference implementation and the Apache Axis open source framework, and also learn how an alternative framework designed specifically for document/literal use can simplify your development. In part two you'll dig into the issues of Web service performance and security. You'll see how the performance of the different approaches from part one stacks up as compared with direct Java RMI, and learn how interface granularity is even more important with Web services than with EJBs. You'll also see how attachments can help performance -- and when you can and can't use them. Finally, you'll get practical pointers on the increasingly important issues of securing and hardening Web services against potential attacks, including a look at WS-Security and related standards. Dennis is a member of the JAX-RPC 2.0 Expert Group as well as a contributor to Apache Axis and the originator of the alternative JiBX-SOAP Web services framework, with in-depth knowledge of all the topics covered. 

 

 

 

Michigan Java Software Symposium 2004: Dallas Edition

-Session Schedule-

 

September 24, 2004

 

 

3:00 - 4:30 PM

 

Session #8: State Machines by Dave Thomas

State machines are a wonderful technique for decoupling your business logic from your low-level code: you can write all the low-level

functionality in code, and knit it all together with high-level state transitions. Why would you want to do that? Because it makes your code

easier to write, and easier to change. The business users just changed their minds about how errors are handled? No problem! Just change a

simple table, and the code adapts!  This talk talks about the basics of state transition diagrams, and looks at alternative state machine implementations, from hard coding through to the open-source SMC state machine compiler.

 

 

4:30- 4:45 PM: Break 

 

4:45 - 6:15 PM

 

Session #9: 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. 

 

Session #10: Naked Objects by Dave Thomas

What if you never had to write a user interface again? What if you could simply expose your busiRTSS 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 busiRTSS objects, and a framework lets your users interact directly with these objects.

 

Session #11: Introduction to Spring by Bruce Tate

With the unbounded growth in complexity of J2EE and EJB, some forward thinking customers are beginning to look to a new breed of lightweight containers, like Spring. In this session, we'll explore fundamental concepts like inversion of control and dependency injection. We'll also see a sample Spring application, where you'll see a taste of the Spring framework's broad reach, including persistence, transactions, user interfaces, and of course, the core configuration and assembly tools.

 

Session #12: Ant for Newbies by Erik Hatcher
All Java projects need a good build process. Ant is the workhorse of the Java world, building, generating, packaging, uploading, deploying, 
notifying and anything else you need to happen automatically.  While Ant is straightforward, there are a number of concepts worth understanding to make effective and efficient use of this tool. First, an understanding of the XML syntax and terminology is in order. Targets, tasks, properties, and data types are the key concepts covered early. Targets form a dependency graph allowing for declarative step-by-step definition of the desired build process.
After getting the basics down, attention will turn to constructing real-world build files using commonly recognized best practices for project structure and Ant usage. Continuous integration and testing complete this session.

 

 

6:15 - 7:00 PM Dinner 

 

7:00 - 8:30 PM: Expert Panel Discussion featuring

 

Bruce Tate, author of "Bitter Java" and "Better, Faster, Lighter Java"

Dennis Sosnoski, IBM Developerworks Contributor

Dave Thomas, author of "Pragmatic Programmer"

Erik Hatcher, co-author of "Java Development with Ant"

Mike Clark, author of Pragmatic Automation

 

 

 

 

 

 

 

 

 

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 25, 2004

 

8:00 -9:00 AM: Continental Breakfast 

 

9:00 - 10:30 AM 

 

Session #13:  GUI Development with SWT and JFace by Ben Galbraith
Eclipse.org'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 an often obtuse and complex API, SWT relies on the host operating system for widget rendering and sports a fairly clean API.  If your goal is to create a Java application that "looks" like a normal Windows (or OS X, or Linux) application, SWT will revolutionize your world.

No matter how well-designed a GUI toolkit's API is, creating GUI's can be a nasty, tricky beast.  Eclipse.org has created JFace, a companion API to SWT, to tame GUI creation process by introducing a large framework of reusable components.  This session will examine SWT and JFace in detail through technical analysis and example programs.  A word of warning, though -- you may never want to write another Swing application again.

 

Session #14: EJB CMP, JDO and Hibernate: Compare and Contrast by Bruce Tate

This session is not a programming session. Instead, it's about the market forces that are shaping the Java persistence landscape. Arguably, the three persistence frameworks with the most momentum are EJB CMP, 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. But the landscape is changing. Announcements about plans for EJB3 and JDO 2.0 have significantly changed the picture for each of these three solutions. You'll see the overall architecture, the best techniques for Java integration, and understand the fundamental problem that each was built to solve. Then, you'll see what the future holds for each. 

 

Session #15: 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.

 

Session #16: Ant 1.6 - What's New by Erik Hatcher
Ant is new and improved!  While your existing build files will work fine, there are some dramatic enhancements that can make build files a lot simpler and more maintainable. The new <import> task adds a level of object-oriented build file writing, including the capability of abstract targets. Rather than the sluggish <antcall>, <macrodef> is the way to go for defining reusable, parameterizable functionality. Further cleanup can be done for standardizing repeated tasks that take identical arguments with <presetdef>. Namespace support has been added as well as the long requested Antlib capability allowing 3rd party tasks easy integration into a build. Executing sub-builds is easy with <subant>. Other nifty new features includes ssh and scp support, custom default excludes, target-less build file support, and scripting true Ant tasks in the language of your choice.  All of these features will be covered, including discussion on steps for refactoring existing build files to leverage them. If this isn't enough, be sure to stir up Ant versus Maven topic to liven things up! This session will assume a basic understanding of Ant syntax and knowledge of targets, tasks, dependencies, properties and datatypes.



10:30 - 10:45 AM: Break 

 

10:45 - 12:15 PM

 

Session #17: 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.

 

Session #18: A Dozen Ways to Get the Testing Bug by Mike Clark

Test-driven development received a lot of attention in 2003, and the interest will grow in 2004. For good reason: everyone agrees testing is important, but now many programmers are claiming that by writing tests first, they see better designs emerge. These same programmers quickly point out that test-driven development makes them feel more productive and less stressed.  It all sounds good, but how do you get started on a real project?

 

Writing tests doesn't have to be difficult or time-consuming.  We'll explore 12 practical ways to start writing JUnit tests, and keep writing them, regardless of your development process.  You'll be able to immediately apply these non-nonsense techniques toward improving your design and testing skills.  In no time you'll be writing better code, and faster!

 

 

 

 

 

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 25, 2004

 

 

Session #19: 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 #20: 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. 

 

12:15 - 1:00 PM Lunch

 

1:00 - 2:00 PM Expert Panel Discussion featuring: 

Bruce Tate, author of "Bitter Java" & co-author of "Better, Faster, Lighter Java"

Ben Galbraith, author of "Professional JSP 2.0"

Dave Thomas, author of "Pragmatic Programmer"

Glenn Vanderburg, architect with Hotels.com

Dennis Sosnoski, IBM Developerworks Contributor

 

1:45 - 3:15 PM

 

Session #21: Effective Enterprise Java by Ted Neward 

>From the book of the same name, listen to 15 of the book's 75 items and advice on how to build enterprise Java applications and systems that will both scale and perform. Items discussed will stretch across all seven chapters (Architecture, Systems, Security, Presentation, Communication, Processing, and State Management), and includes The Ten Fallacies of Enterprise Computing. Hear it before you can buy it, from the author who wrote it. (This is a 3 hour session with a 15 minute break)

 

Session #22: XML Data Binding by Dennis Sosnoski (3 hour session with a 15 minute break)

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 "glue" 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. Dennis is both a member of the JAXB 2.0 Expert Group and the primary developer of the JiBX project, so you can be sure you're getting the best information on both approaches.

 

Session #23: How to make Swing Sing by Ben Galbraith

Few Java API's catch as much flak as Swing.  Whether they accuse it of being too slow, too bloated, or too complex, Swing's critics rarely miss 
an opportunity to speak their mind.  Yet for all its flaws, and they are plenty, there's a diamond in Swing's rough.  With the right techniques 
(and third-party libraries), Java developers can accomplish some pretty amazing things with Swing.  The session will demonstrate a broad range 
of options for making Swing applications run fast, look beautiful (and highly customized), and easier to write and maintain. 

 

Session #24: Improving testability with Spring by Bruce Tate

Programming with Spring lets you build simpler J2EE applications in a lightweight container, without the headaches of other more invasive frameworks. It has a side benefit: testability. Learn how to use Spring to decouple your code, and invite better and finer-grained tests. See how you can begin to run integration tests in a broader scope, without loading your entire application. Learn techniques to effectively layer your applications, and organize your application contexts.

 

3:15 - 3:30 PM Break

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 25, 2004

 

 

 

 

3:30 - 5:00 PM

 

Session #25: Effective Enterprise Java by Ted Neward (Continued)

 

Session #26: XML Data Binding by Dennis Sosnoski (Continued)

 

Session #27: Converting XML into HTML, PDF, and Vector Graphics: An In-Depth Look at XSLT, XSL-FO, and SVG 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.  XSLT is the foundation technology that enables XML to be transformed.  It's classic use is to convert XML into HTML/XHTML.  This session will provide an XSLT tutorial and demonstrate its use.

But XSLT is only the beginning.  This bulk of this session will 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 #28: Software Development Heresies by Glenn Vanderburg

Much of what you were taught about software development is wrong.  Much "conventional wisdom" is anything but wise.  Many of the most loudly heralded technologies are deeply flawed.  What's going on?  Why does our industry keep bouncing from one new technological or methodological savior to the next?  And why do we keep thinking "this one's really it"?  Will we ever learn?  Come hear some straight talk about the snake oil you've been sold over the years, and see if you're being sold some more right now.  Bring your own stories of programming's misguided movements and hideous hypefests to share with us!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 26, 2004

 

8:00 - 9:00 AM: Continental Breakfast 

 

9:00 - 10:30 AM: 

 

Session #29: TDD for the web tier: Testing web applications by Rick Hightower
TDD is a standard practice in software development. Applying TDD to web application development has certain issues. There are many tools that allow
facilitate TDD for Java web development. This session covers these tools and strategies for doing TDD for web applications.

 

Session #30: Tapestry by Example by Erik Hatcher (3 Hour session with a 15 minute break)
Tapestry offers true event-driven, component-oriented web development. The concepts in Tapestry are not new in traditional desktop development, but are mostly foreign to even seasoned web developers. For many, this can be a dramatic paradigm shift. The purpose of this session is to introduce Tapestry gently through interactive demonstrations.  Tapestry began with bold missions. HTML templates are pure HTML, allowing easy integration between graphic designers and developers. Components are reusable, even across projects. JavaScript is a first class citizen. Write application code, not plumbing. Report errors precisely and robustly. Tapestry lives up to each of these goals, and goes beyond.  Live demonstrations throughout, each of Tapestry's major features will be showcased. While this session focuses on Tapestry, attendees will likely be interested in how it compares, and more often contrasts, to other frameworks. The speaker will be more than happy to oblige discussion on other frameworks as it relates to Tapestry

 

Session #31: Introduction to Aspect-oriented programming with AspectJ by Ramnivas Laddad

AOP enables modularizing implementation of crosscutting concerns that are abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concern in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to changes in system requirements.

 

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with most commonly used IDE, which make the Java developer become productive.  This presentation will introduce whys and hows of AOP, its concepts, and debunk myths around it. It will also introduce the AspectJ programming language along with several examples. (3 Hour Presentation with a 15 minute break.)

 

Session #32: Under the Hood of Java Memory Management by Glenn Vanderburg
Most of the time, Java's automatic memory management works really well-it's one of the things that makes programming in Java a pleasant and productive experience, and it's nice that we don't have to worry about managing memory manually.  However, although it's usually nice to ignore memory management, occasionally we have to pay close attention. Sometimes we need to take control of certain aspects of memory management. Sometimes Java programs do exhibit memory leaks, or unacceptably long garbage collection pauses, or very poor overall performance. But because Java's memory management is supposed to be "fully automatic," it can be difficult to find out what's really going on inside the VM.

Java memory management is just like most labor-saving simplifications: it works well most of the time, but for the weird edge cases when it doesn't work quite right, it can be a nightmare.  This talk opens the hood, examining the inner workings of Java's memory system, including allocation and garbage collection. We'll look at how to control the memory system and interact with it, what's costly and what's not, how to tune the garbage collector and when to switch to a different GC algorithm, and other topics.

 

10:30 - 10:45 AM Break 

 

10:45 - 12:15 PM

 

Session #33: Tag-Oriented JSP Design by Glenn Vanderburg

Custom tags -- not other people's tag packages, but the ones you write yourselves -- are extremely powerful tools for JSP-based applications.  

They can improve your design and clean up your code.  Unfortunately, tag-oriented JSP development is underused and undersold.  This talk 

includes a brief intro to the basics of custom tag development, but the focus is deeper:  sophisticated tag programming tricks, design 

techniques, useful ways tags can cooperate with each other, and so on.  Learn how to take control of JSP and turn it into a language that 

really supports your application.

 

Session #34: Tapestry by Example by Erik Hatcher (Continued)

 

Session #35: Introduction to Aspect-oriented programming with AspectJ by Ramnivas Laddad (Continued)

 

Session #36:  What's coming in JDK 1.5 by Ted Neward
In this talk, we'll look at some of the proposed features and JSRs that are unofficially supposed to be part of the JDK 1.5 (code-named "Tiger") release sometime in 2004, from one of the guys who's defining part of that release. We'll talk about generics, the enhanced for loop, static imports, typesafe enums, autoboxing, Isolates, the java.util.concurrent package, and metadata, among others.

 

12:15 - 1:00 PM Lunch

 

1:00 - 1:45 PM Quick Strike - Panel Discussion 

Ramnivas Laddad, author of AspectJ in Action

Rick Hightower, author of Struts Live & Java Tools for Extreme Programming

Glenn Vanderburg, architect with Hotels.com

Ted Neward, author of "Effective Enterprise Java"

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 26, 2004

 

 

1:45 PM - 3:15 PM 

 

Session #37: JSR166: Java 1.5 Concurrent Programming Utilities by Glenn Vanderburg
At long last, Java 1.5 introduces a standard suite of utility classes for concurrent programming. Loosely based on Doug Lea's "util.concurrent" package, the new "java.util.concurrent" package specified by JSR166 is different, and improved, in many ways.

This talk covers basic concepts of multithreaded programming and then proceeds with a survey of the new facilities, showing how they can be used to implement common concurrent patterns. You'll learn how to write better, faster, more robust multithreaded Java programs, with fewer debugging woes. 

 

Session #38: AppFuse- Start your next Struts application with a bang!  (Intro) by Rick Hightower
Some times the hardest part of any task is just getting started. You just need a little gas to start your engine. AppFuse is a good example to get the
ball rolling. AppFuse is a starter web application that includes support for Struts (web app framework), XDoclet (code and deployment file generation),
Hibernate (OR Mapping), DBUnit (testing code that relies on databases), Canoo (testing JSP pages), JUnit (framework for testing Java code),
JUnitReport(test reports), StrutsTestCase (testing struts), and much more.  It implements a web application that has user management that is integrated with the J2EE security model. It also comes with step by step guides and to develop and use the framework. It ships with starter ant scripts that runs all of the tools you need to develop the sample application. Simply put, it gives you a starting point to develop applications. This session shows how to get started using AppFuse to create J2EE web applications.

 

Session #39: Aspect-oriented Refactoring: Taking refactoring to a new level by Ramnivas Laddad

Refactoring techniques have gained popularity due to their practical value in creating more agile code. Recently, aspect-oriented programming (AOP) has received an increased attention due to its power in encapsulating crosscutting concerns. Refactoring allows reorganizing code while preserving the external behavior, while AOP facilitates modularizing crosscutting concerns in a system through use of a new unit of modularity called aspect. Aspect-oriented refactoring synergistically combines these two techniques to refactor crosscutting elements.

 

Individually, refactoring and AOP both share the high-level goal of creating systems that are easier to understand and maintain without requiring huge upfront design effort. A combination of the two - aspect-oriented refactoring - helps in reorganizing code corresponding to crosscutting concerns to further improve modularization and get rid of the usual symptoms of crosscutting: code-tangling and code-scattering.

 

Aspect-oriented refactoring provides means beyond conventional refactoring techniques. While steps in conventional refactoring modularize code to a certain point, the use of AOP squeezes out the code that cannot be further refactored. Aspect-oriented refactoring offers substantial improvement to the code in a variety of situations: exception handling policies, local contract enforcements, resource management and optimization schemes, concurrency control, worker object creation, and so forth.  Benefits of aspect-oriented refactoring are many. Initially the attractive part of aspect-oriented refactoring is the code saved. However, after a short duration, the real benefit is found in resulting code that is easy to understand, highly consistent, and simple to change.  This presentation will examine fundamentals of aspect-oriented refactoring, a few common patterns, and a few examples in J2EE space. 

 

Session #40:  Effective Enterprise Java by Ted Neward 

>From the book of the same name, listen to 15 of the book's 75 items and advice on how to build enterprise Java applications and systems that will both scale and perform. Items discussed will stretch across all seven chapters (Architecture, Systems, Security, Presentation, Communication, Processing, and State Management), and includes The Ten Fallacies of Enterprise Computing. Hear it before you can buy it, from the author who wrote it. (This is a 3 hour session with a 15 minute break)

 

 

3:15 - 3:30 PM Break 

 

3:30 - 5:00 PM

 

Session #41: Combining JSF, Struts and Tiles by Rick Hightower
By using Struts, Tiles, and JavaServer Faces (JSF) together, developers can ensure a robust, well-presented Web application that is easy to manage and
reuse.  The Struts framework is the current de facto web application development framework for Java. The Tiles framework, which ships as part of Struts, is the de facto document centric, templating-component framework that ships with Struts.

Struts and JSF do overlap. However, Struts provides complementary features above and beyond the JSF base. Struts works with JSF via its Struts-Faces
integration extensions.  Using these extentions allows companies to keep the investment that have in Struts and still migrate to the new JSF programming model. Knowledge of Struts and JSP will help you get the best out of this session.

 

Session #42: Runtime Code Generation for Java and Beyond by Glenn Vanderburg
Every now and then, it's really helpful to be able to generate a new Java class at runtime. Some problems just can't be solved any other way. It's one of those troublesome tasks: it's fairly tricky to do, and you only need to do it occasionally-but when you need it, you really need it (and usually you need it yesterday). So you have to start essentially from scratch, learning about how to do it on the fly, under pressure.

This talk is designed to help. You may not face this problem for a while, so there's no point focusing on the arcane details that you'll soon forget. Instead, I'll give you what you'll need to quickly come back up to speed when the time comes. You will see some real bytecode generation, but more importantly we'll discuss the types of problems where runtime code generation can save the day, the variety of tools and techniques that are available, and a step-by-step approach to getting the job done. Finally, for those who may be working with more dynamic languages, I'll show how powerful runtime code generation can be when it's easy.  We'll start simply, but before we're done we'll be pretty deep into the bag of tricks. Come along, and be ready for the next time you need more than what's in your JAR file.

 

 

 

 

 

Michigan Java Software Symposium 2004

-Session Schedule-

 

September 26, 2004

 

 

3:30 - 5:00 PM

 

Session #43: Lucene in Action by Erik Hatcher
Lucene is a highly scalable and fast search engine API. Lucene is so good, in fact, that it is being used at the heart of a new open-source Google killer. This presentation will take an outside-in approach to Lucene, hilighting several real-world uses of it and then digging in to its internals to learn what makes it tick. One of the beauties of Lucene is that it is very easy to use, yet has significant power. If you are not familiar with this Jakarta gem, you are missing out. Come see what you've been missing and put Lucene in action right away.  Several case studies of high-profile sites leveraging Lucene will begin the session, discussing what makes them tick. These case studies demonstrate that Lucene is plenty powerful enough for your search needs 
yet developer cleverness on how to use it is what adds value.  Lucene's straightforward API then takes the stage, including specifics on indexing, searching, updating, and techniques to parallelize them. Digging even deeper, it is imperative to understand Lucene's analysis process in detail. Textual analysis can include stemming, stop word removal, synonym injection, and much more. The majority of user questions on Lucene involve a misunderstanding of the analysis process and what that means for searching; this session answers these questions.  

 

Session #44: Effective Enterprise Java by Ted Neward (Continued)

 

 

 

 

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://gr-jug.org/pipermail/jug/attachments/20040823/26de742d/attachment-0001.htm