Loading ...
Sorry, an error occurred while loading the content.
 

Join us for the Fall Edition of the Rocky Mountain Software Symposium: November14-16th

Expand Messages
  • Jay Zimmerman
    Rocky Mountain Software Symposium: Fall Edition When: November 14-16, 2003 Where: Marriott Denver West Don t miss your chance to choose from over
    Message 1 of 1 , Aug 22, 2003
      Rocky Mountain Software Symposium: Fall Edition



      When: November 14-16, 2003

      Where: Marriott Denver West



      Don't miss your chance to choose from over fifty education and solution
      based sessions (see below for details) at the Rocky Mountain Software
      Symposium: Fall Edition. You have the opportunity to attend one of the
      best Java & related technology conferences offered and is located right
      here in Denver. Please see the session listing below for further
      details.




      * Limited Attendance (200)
      * Nationally Recognized Speakers
      * In-depth Discussions
      * Peer Exchange
      * Unparalleled Access to Speakers

      * Expert Panel Discussions
      * Hands-on Code Examples
      * Best Practices
      * Insight on Cutting-Edge Tools
      * No Product Demonstrations



      For more information and registration details,
      http://www.nofluffjuststuff.com/2003-11-denver/index.jsp or

      contact Jay Zimmerman, RMSS Symposium Director at
      jzimmerman@...
      <mailto:jzimmerman@...> .



      The early bird registration for RMSS 2003 is $595/person and is
      available thru 10/14/03. We have a special

      $50 discount available to all XPDenver members. Please use the discount
      code, "xpdenv545".



      The registration fee includes:



      * Admission to the symposium
      * CD with all presentational content
      * Handouts for each session attended

      * Meals & snacks







      We have some great development team discounts:



      5-9 Attendees: $ 545/person

      10-14 Attendees: $ 495/person

      15-24 Attendees: $ 450/person

      25-over Attendees: $ 400/person





      Rocky Mountain Software Symposium: Fall Edition 2003



      -Session Listing-



      JDO and Transparent Persistence by Dion Alamer
      Many developers are demanding transparent persistence. Java Data Objects
      (JDO) is aiming at standardizing this need in the JCP. This talk shows
      you what JDO is, how it fits in with J2EE technology, and some of the
      politics behind it.



      WebWork - Strutting the OpenSymphony way by Dion Almaer
      WebWork is one of the larger MVC frameworks for J2EE. This talk looks at
      some of the features that make this framework unique - such as it's
      command driven nature, it's ability to participate in a test driven
      development environment, the interceptors and AOP features and the new
      inversion of control based components. It'll also touch on the highly
      religious Struts vs WebWork debate.



      Faces - A new face of web app development by Dion Almaer
      JavaServer Faces gives us a standard server-side component framework.
      This talk looks at the ins and outs of this new way of doing web app
      development.



      Enterprise AOP with AspectJ by Ron Bodkins

      This session builds on the core concepts of Aspect Oriented Programming
      (AOP) by demonstrating its use for enterprise Java development. AOP has
      become a major topic in the future of enterprise Java development. We
      provide a conceptual road map, tangible examples of how AOP works and
      can be beneficial, as well as discussing anti-patterns (how not to use
      AOP).



      The presentation illustrates uses of AOP with examples ranging from
      development support via standards enforcement and profiling, through
      auxiliary areas such as timing and systems management to core design
      topics like persistence and business aspects. It demonstrates techniques
      for using AOP with major J2EE technologies (i.e., servlets, JSPs,, EJBs)
      and adjunct technologies such as Struts. The tutorial primarily uses
      AspectJ (the leading AOP implementation). At the end of the talk,
      participants should have an understanding of both the potential and the
      pitfalls for applying AOP for enterprise Javat. The tools used in the
      tutorial are all freely available via open source so participants can
      apply the techniques shown in their own projects. AspectJ is available
      at <http://eclipse.org/aspectj> http://eclipse.org/aspectj.



      Application Security Integration by Ron Bodkins

      One of the core values of Java has always been a secure platform. In
      past, many projects used J2EE security with application server-specific
      extensions. The JAAS approach to application security promises to make a
      major change to this model, as does BEA's new Weblogic 8.1 Security
      Framework.



      Most projects need to integrate application security with third party
      products such as databases, message queues, and single sign on servers.
      And the recent flurry of XML and Web services activities has produced
      several important new security standards: XML Digital Signature, XML
      Encryption, SAML, XACML, and the WS-Security draft. Aspect-Oriented
      Programming also promises to greatly improve consistency and flexibility
      in security integration, while also raising some security questions.



      This presentation explains these current and emerging trends in
      application security. It outlines the technologies, assesses whether and
      for what they are important, what approaches there are to integrating
      them, and what the trade offs are for each. It addresses these topics by
      mapping them into common technology "stacks" and into uses cases such as
      access control, recording audit trails, tracking user identity between
      tiers and systems, customizing UI displays to only show, and (links to)
      authorized items.



      Testing with Virtual Mock Objects by Ron Bodkins

      More and more projects have become "test infected" and realize the
      importance of effective unit and integration testing for improving
      quality and to enable refactoring to keep code clean . Testing harnesses
      such as JUnit have proven very helpful. However, there many components
      are not easily tested. Too many tests require complex set up, extensive
      interface changes to introduce "mock objects", produce results that are
      difficult to interpret, and require too much drugery to implement.



      Performance Testing by Mike Clark

      Tuning EJB 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 some common pitfalls related to the
      EJB performance tuning process discussed in the upcoming book, "Bitter
      EJB". We'll sacrifice an application with a familiar antipattern as a
      crash test dummy for performance testing. Then we'll improve its
      performance 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. As a result of
      attending this session you'll be able tune EJB 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.



      Building Real World Apps with JSF by Bill Dudney

      This presentation is on building real world applications with JSF. Most
      of what we find in the RI and the spec is about the technology itself
      and very little about how to write encapsulated applications with JSF.
      This presentation is a practical hands on discussion of how to build a
      real world JSF application. The focus is on moving towards the vision of
      component based application assembly in the WebTier, i.e. keep the UI in
      the UI and 'assemble' it with backend components with event listeners. I
      will show the attendees how to build a good UI with JSF
      (architecturally, not pretty looking ;-) and how to connect that UI to a
      database. I will also show techniques and patterns for connecting to
      'the backend' through session beans as well as through plain old java
      objects (POJO's) using Relational/Object binding tools as well as JDBC.
      The discussion will be very practical and focused on keeping the UI code
      in the UI and the rest of the code out of the UI.



      J2EE AntiPatterns by Bill Dudney

      This session is about AntiPatterns in building applications with J2EE,
      but the audience is not left high and dry stuck in their AntiPattern.
      One or more refactorings are presented as a means to get out of each
      AntiPattern. AntiPatterns for each major area of the J2EE specification
      will be covered. Each AntiPattern is presented with practical
      information about how to recognize the AntiPattern, what will likely
      happen if the AntiPattern is not address and how developers get caught
      in the AntiPattern in the first place. Next an example of code or design
      stuck in the AntiPattern will be presented which will provide the segue
      into the Refactoring(s) that provide the way out of the AntiPattern. The
      refactoring will focus on taking the AntiPattern example through the
      mechanism of the Refactoring step by step until the AntiPattern is gone.
      In essence the AntiPatterns in this book formalize the concept of 'code
      smells' that Fowler discusses in his great book on Refactorings. The
      discussion will cover each of the major sections of the J2EE API set.



      Anti-Patterns in Using the Jakarta Projects by Bill Dudney

      This presentation is on Pitfalls in using selected software from the
      Jakarta project. One or more refactorings are presented as a means to
      get out of each Pitfall. Pitfalls for Struts, Ant and Cactus will be
      presented. Each Pitfall is presented with practical information about
      how to recognize it, what will likely happen if the Pitfall is not
      address and how developers get caught in the Pitfall in the first place.
      Next an example of code stuck in the Pitfall will be presented which
      will provide the segue into the Refactoring(s) that provide the way out
      of the Pitfall. The refactoring will focus on taking the Pitfall example
      through the mechanism of the Refactoring step by step until the Pitfall
      is gone.



      Alternatives to Swing by Ben Galbraith

      Designed for both GUI newbies and Swing experts; introduces three
      alternative frameworks to Swing.



      Generating Professional PDFs with Java and XSL-FO by Ben Galbraith

      This session covers the interesting XSL-FO spec and doing cool things
      with FOP and RenderX. Will also cover issues relating to professional
      printing, such as dealing with CMYK and spot colors.



      Validating Ant Build Files by Ben Galbraith

      Ant 1.6 finally allows you to use XML namespaces in your build files.
      Come see where you can get a schema to validate Ant build files and how
      it can improve your Ant experience.



      Code Generation in-the-small with Ant, XML, and XDoclet by Stuart
      Halloway

      By now, everyone knows that Ant is "make on steroids." Beyond its
      usefulness in managing standard application builds, Ant is particularly
      useful for code generation in-the-small. "In-the-small" implies code
      generation techniques that do not require commitment to a particular
      framework or approach. Instead, code generation in-the-small uses simple
      string manipulation, regular expressions, and XML parsing to add power
      and flexibility to *your* project implementation, without radically
      changing the way you code. This talk will demonstrate the Ant tasks and
      extensions most suited to

      code generation, including XSL transformations and XDoclet.



      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.



      In this session, we will start from a Java class, and experiment with
      Java2WSDL's configuration settings. For each option, we will discuss
      real-world scenarios where that option might be used, and its
      implications for interoperability with other leading web service
      implementations. We will also note where AXIS is implementing a standard
      such as JAXRPC, and where AXIS goes beyond the standards.



      JCA & JCE by Stuart Halloway

      The Java Cryptography Architecture (JCA) and Java Cryptography Extension
      (JCE) provide a complete, flexible, and extensible solution to most
      cryptography needs. This talk covers JCA and JCE in three parts: 1).
      JCA and JCE are complete -We start at the beginning, with the basic
      crypto operations, including encryption, hashing, message integrity,
      digital signatures, and key management. You will see what these
      operations do, why you need them, and how JCA and JCE implement each.
      2). JCA and JCE are flexible -JCA and JCA are built around a provider
      mechanism, which allows flexibility in choosing algorithms and
      implementations from multiple vendors. You will see how to configure the
      virtual machine to select different providers, and how to
      programmatically select a provider at runtime. 3). JCA and JCE are
      extensible -The provider mechanism also allows you to develop your own
      providers. You will see how to write your own custom provider and
      integrate it into a standard Java runtime environment.



      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.



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



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



      Advanced Servlets by Jason Hunter

      This talk, given by the author of "Java Servlet Programming" (O'Reilly),
      will teach you the latest and greatest on servlet programming. We'll
      cover servlet best practices including: choosing a servlet framework,
      making performance optimizations, handling configuration files, how to
      think of sessions, caching strategies, and making file downloads work
      reliably across browsers. You'll also learn what's coming next in
      Servlets 2.4.



      What the X is XQuery? by Jason Hunter

      XQuery, if it lives up to expectations, may be the most important thing
      to happen in server-side programming this year. XQuery is a W3C
      specification for querying XML or anything that can have an XML facade
      such as a relational database. It has the backing of all the big
      players including Oracle, IBM, BEA, and Microsoft, and has several open
      source implementations as well. XQuery makes possible the exciting
      possibility of a single query that combines an incoming purchase order
      in XML format, an archive of catalog data also in XML format, and an
      inventory system held in a relational database. In this session you'll
      learn how to use XQuery, when to use XQuery, and which implementations

      to trust.



      Web Services Tutorial in Java by Jason Hunter

      This is not another "fluff piece" about web services but rather a
      get-your-hands-dirty practical guide to creating and consuming web
      services using the latest toolkits. You won't be bored seeing piles of
      SOAP envelopes and WSDL descriptors. Instead, you'll learn how best
      to consume web services like what Google and Amazon offer, see how SOAP
      differs from REST, and learn to use both Apache Axis and JAX-RPC as
      implemented in Sun's JWSDP. You'll also see how easy it can be to set
      up your own web services, although we intentionally don't cover the
      advanced details of web service deployment as it's still an area
      undergoing major changes.



      Core Language Changes in J2SE 1.5 by Jason Hunter

      J2SE 1.5 will introduce a number of significant language enhancements,
      with the goal to make programming in Java more expressive,
      developer-friendly, and safer, while minimizing incompatibility with
      pre-existing programs. The language changes include: generics, typesafe
      enums, autoboxing, an enhanced "for" loop, a static import facility, and
      a general-purpose metadata facility. This talk describes the proposed
      changes and shows how they work together to improve the Java language.



      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.



      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.



      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.



      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.



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



      Discovery & Lookup of Cooperating Distributed Services by Paul Perrone

      Many Java and J2EE development approaches resort to simple look ups of
      distributed services based on a known URI and name, or simply co-locate
      services within the same process environment. What if you were to infuse
      the capability to build a cooperating and federated network of services
      that could discover each other and new features offered by each other in
      order to coordinate in accomplishing tasks? This talk describes the open
      standards-based Java interfaces available to you for achieving this goal
      and presents a design of one such solution.



      Wireless Communications for Distributed Services by Paul Perrone

      Low cost and easy to configure local area wireless communications
      networks has opened the floodgates for organizations ranging from bars
      to retail stores to construction sites to offer a variety of wireless
      application services to their customers and employees. However, fixed
      and temporary obstructions and interferences require a design that is
      reliable and available. This talk describes the issues and Java-based
      design of a low-cost wireless communications approach for enabling
      distributed applications to communicate in a reliable and available
      fashion.



      Securing Distributed Applications by Paul Perrone

      The array of options available to the Java and J2EE developer for
      infusing security into their applications is dizzying. Throw on top of
      that the need to know where and when to use each technology and how the
      technologies integrate, and you have a recipe for nausea. This talk ties
      together some of the Java and J2EE security piece parts by describing
      the design of an authentication, authorization, and confidentiality
      solution to securing applications and data distributed across an
      enterprise network.



      Eclipse IDE by Nimret Sandhu

      This talk will focus on using IBM's Eclipse IDE for Java projects.
      Nimret will talk about using the Eclipse's IDE's extensive features most
      effectively in your java projects - from perspectives to it's cvs
      integration. He will also talk about the refactoring capabilities of the
      IDE and it's extensibility via plugins.



      Transitioning to Agile by Alan Shalloway

      More and more companies are beginning to see the need for Agile
      Development. It is becoming clear that attempting to get full
      requirements up-front and having a completely planned, rigid approach to
      software development doesn't work but is more of a "hope over
      experience". How to proceed isn't so clear. Do we go with the Rational
      Unified Process (RUP), XP (eXtreme Programming), Scrum, or even another
      methodology? The investment in the new techniques seems daunting,
      expensive and by no means assured of success. The groundbreaking book
      "Extreme Programming Explained" made it sound like an all or nothing
      approach. Given it's controversial practices and mantras, this has been
      a leap few managers have been willing to make. However, there are ways
      to transition to agile that are straightforward, intuitively clear,
      comfortable and risk adverse.



      Emergent Design: Design Patterns & Refactoring by Alan Shalloway

      The two approaches of creating quality, high-level, up-front designs
      with design patterns or relying on emergent design using refactoring as
      espoused by XP seem opposed to each other. This seminar illustrates why
      design patterns and refactoring are actually two sides of the same coin.
      Refactoring is very important as a method of improving design to
      accommodate new requirements. It is often touted as a way to fix code
      mistakes. However, avoiding the code mistakes in the first place is a
      better way to go. In this case, refactoring is used to accommodate
      design changes required by new requirements.



      The Need for Agility by Alan Shalloway

      Perhaps you've heard the phrase "paralysis by analysis," where all too
      often project staff spend too much time on analysis and design. On the
      contrary, they might spend too little time on the initial planning and
      instead leap right in to the coding. On one hand, there is great value
      in getting complete requirements and doing up-front design. Conversely,
      we know the requirements are going to change. Furthermore, the more
      work we do up-front, the longer it takes until we can get feedback about
      what we've done. Both feedback from the customer and feedback on the
      technical approach we've taken, are extremely important. Delays in
      getting this information dooms many projects. This seminar will review
      these issues and explore how light methodologies can be more useful in
      short development cycles.



      J2EE Web Foundation by Sue Spielman

      J2EE 1.4 is the next generation of the Java Server Enterprise platform.
      Find out what new features have been included in JSP 2.0 and Servlet 2.4
      for doing enterprise web development. This session will take a look at
      the J2EE 1.4 landscape to see what's hot, what's new, and what's changed
      in the areas related to Web development. We will take a functional look
      at the JSP and Servlet arenas regarding web development. With JSP 2.0,
      we'll talk about using the new expression language, JSP fragments, .tag
      files, and Simple Tag Handlers, as well as how to use the JSTL in your
      JSPs. We'll also look at using new features in Servlet 2.4 including:
      deployment descriptor changes, building better filters, and how to use
      the new Servlet APIs to handle web event listeners in your applications.
      This will be a functional session with code examples throughout.



      JSTL - The JSP Standard Tag Library by Sue Spielman of Switchback
      Software

      The JSP Standard Template Library provides custom tags that follow a
      base design philosophy that allow page authors to work in a script-free
      environment. Attendees of this session will get a look at what the JSTL
      is, along with a detailed description of the available custom tags
      including: iteration, conditional processing, expression language
      support, XML processing, XSL transformation of XML documents,
      I18N-capable support for localized formatting and parsing, and database
      access (SQL). JSTL is being developed through the Java Community Process
      as JSR-52 and is included in the Java Web Services Developer Pack (Java
      WSDP). We'll look at the various functional areas that are provided in
      the Library, as well as take a detailed look at how to use some selected
      tags. Come find out how you can take advantage of the features of the
      JSTL in your Web application development.



      Developing Applications with Struts v1.1 - Advanced by Sue Spielman

      If you're familiar with Struts or you're getting ready to use it as the
      framework for your enterprise application development, this session is
      for you. This is not an introduction to the Struts framework, but rather
      is an in-depth look at the framework and how to make the best use of it
      in web application development. This session will include learning and
      using all of the new features available in Struts v1.1.



      This session just about begins where the Using the Struts Framework to
      Build Enterprise Applications session leaves off. In that session the
      basics are covered, in this session we put the pedal to the metal and go
      much further in-depth into all that Struts can do. We will basically
      build an application that shows how all of the features work and can be
      used in the real world. Get down and dirty (coding that is) with the
      author of 'The Struts Framework: Practical Guide for Java Programmers'.



      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.



      Agile MDA by Gyl Savoie

      This presentation examines an automated approach for translating
      business models into the application code necessary to implement a
      business solution. Development projects frequently proceed from business
      definition directly to coding tasks. This ignores the intermediate
      application-specific layer of definition, and contributes to deviations
      from an organization's platform-specific architectural standards. The
      application model is where business requirements are architected to a
      platform-specific technology implementation. Lack of attention to this
      layer contributes to lack of continuity between architectural design and
      the implemented code. A model-driven and pattern-driven approach to
      development introduces this layer. The use of transformation patterns to
      change business requirements into a platform-specific model enforces
      J2EE architectural standards and assures the best coding standards.



      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.



      J2EE vs. .net by Bruce Tate & Ted Neward

      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.











      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.



      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. This is a 3
      Hour Session.



      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.



      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.



      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.

      Pragmatic Version Control by Dave Thomas
      A team using version control properly can produce releases more
      reliably, fix bugs in prior versions more accurately, and develop
      software in parallel more efficiently. Despite these benefits, roughly
      40% of teams use no version control at all, and many of the remaining
      60% use it ineffectively. This talk focuses on the practical use of
      version control using the popular and freely-available CVS system. It is
      recipe-based, meaning that teams can match material in the course to
      their needs immediately. Learn how to manage vendor branches, the easy
      way to prepare for releases, and the simple way to back out last week's
      good idea (that turns out not to have been so good after all).



      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.



      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!



      Practical JMX: Separating System Facilities from Application Logic by
      Greg Vaughn

      This talk gives a short overview of JMX, then jumps straight into a case
      study examining why JMX was chosen, how it helped, and how its use has
      influenced future architectural plans all the while gradually picking up
      more details of JMX. The end result is a fully reusable component that
      monitors a JMS dead letter queue for rolled-back deliveries and requeues
      the messages after a configurable time delay. The component is not only
      reusable, but has already been reused, and the QA department is
      extremely pleased at the quality of it. The component nature of JMX was
      a huge factor in the success of it.



      Practical Performance: When IO is the bottleneck by Greg Vaughn

      This talk discusses a batch-mode application that initially was
      projected to require 3 hours to run 100,000 records of data. The process
      is very IO intensive. Through several strategies (NIO, SQL
      optimizations, refactoring the algorithm, etc), the runtime was reduced
      to 30 minutes. The application was profiled at each step and the lesson
      learned helped to drive the next optimization attempt. The end result of
      the code was not only a factor of 6 faster, but also better factored and
      easier to read.



      Squeezing Java by Alan Williamson

      Java is a very powerful language, and while it offers the developer a
      rich array of tools, the fundamentals mustn't be overlooked. Improving
      your code at the core layer will result in great improvements in
      efficiency and producing (hopefully) less bugs. We'll look at the do's
      and don'ts of programming and learns lots of hints and tips that will
      accelerate your Java coding.

















      [Non-text portions of this message have been removed]
    Your message has been successfully submitted and would be delivered to recipients shortly.