|
Atlanta Java Software Symposium 2003
When: October 24-26, 2003 Where: Hyatt Regency, Marietta
Don't miss your chance to choose from over fifty education and solution based sessions (see below for details) at the Atlanta Java Software Symposium 2003. You have the opportunity to attend one of the best Java & related technology conferences offered and it is right here in Atlanta. Our session schedule is listed below for your perusal.
For more information and registration details, http://www.nofluffjuststuff.com/2003-10-atlanta/index.jsp or contact Jay Zimmerman, AJSS Symposium Director at jzimmerman@nofluffjuststuff.com.
The early bird registration for AJSS 2003 is $595/person. For AJUG members, we have an additional $50 off discount thru 9/26/03. Use the discount code, “ajug545” when registering online.
The registration fee includes:
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
Atlanta Java Software Symposium 2003
-Session Listing-
JDO and Transparent Persistence by Dion
Almaer
WebWork - Strutting the OpenSymphony way
by Dion Almaer
Faces - A new face of web app development
by Dion Almaer
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.
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.
This session provides an overview of JUnit and mock objects. It also demonstrates a new way of writing JUnit test cases that uses AOP to write "virtual mock objects." These simplify the isolation of tested classes from others, allow easy introduction of stubs in a context sensitive manner without compromising the original design, and facilitate thorough analysis of test results.
Effective Object Orientation by James
Duncan Davidson
Mac OS X Overview by James Duncan Davidson
Effective
Collaboration by James Duncan Davidson Objective-C Essentials by James Duncan
Davidson
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
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.
Introduction to Lucene by Erik Hatcher How would you like a mini-Google embedded in your Java application? Lucene is just the thing for embedding sophisticated, highly scalable, and incredibly fast searching into your application. This session introduces Lucene, including what it is not. Lucene is only an API, so it requires development. The development time to be up and running with Lucene is minimal, and its API is relatively simple - after this session you will have the code and knowledge to immediately build your own custom search engine.
Ant Primer by Erik Hatcher 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!
Applied Ant by Erik Hatcher There is a lot more to Ant than just understanding its syntax and capabilities. This session covers using Ant with the following technologies: EJB, XML, web services, and web applications. Techniques for unit testing and continuous integration are covered. And finally, many of the discussed techniques will be showcased interactively. Note: this session assumes you have attended the “Ant Primer” session, or are already familiar with Ant’s basics.
Introduction to XDoclet by Erik Hatcher 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.
eXtreme XDoclet by Erik Hatcher An out-of-the-box installation of XDoclet will work wonders, but there can be a need for more than the basics. For example, rather than accepting the basic EJB lookup utility helper class, a custom template can be provided to generate a more sophisticated “proxy” object decoupling the presentation tier from direct EJB access and allowing statistics to be gathered for each method invocation. Providing a custom template for existing XDoclet functionality is just the beginning, though. Generating custom text files (XML, properties, Java source code, etc) based on any information nested within source code can save hours, days, or more in a projects lifetime. This session details XDoclet’s templating language, how to extend it with custom tag handlers, and even how to write custom subtasks to control the processing in sophisticated ways. Erik used XDoclet to generate the Ant task reference for his book, Java Development with Ant, which required the use of all of these advanced techniques to process Ant’s own source code to distill its valuable information
Scripting on the JVM by Joey Gibson Many popular scripting (or dynamic) languages, such as Ruby, Python and Scheme are now available running on top of the Java virtual machine. These languages offer many exciting possibilities when run this way, including easy prototyping of Java programs, creation of utility programs to interact with existing Java programs, interactive execution of Java code and, typically, the ability to embed the interpreter in a Java program to provide users with a customization engine.
These languages, due to their dynamic nature, dispense with the edit-compile-run cycle. Couple this with the interactive mode that most of these languages support and you have a powerful combination. In this session we will spend some time discussing the various languages that are available on the JVM, specifically Python and Ruby, in general; in other words, the basics of each language, outside the JVM. We will then dive in to the specifics of using the Java-enabled versions, Jython and JRuby. We will see examples of interactive sessions, custom programs and how to embed them. We will also touch on some of the other available languages like Rhino (JavaScript) and some of the less well known languages like JudoScript.
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.
Model Driven Architecture can be agile. This presentation will illustrate how patterns and models can work together to separate the architectural code from the application code. We will explore how a custom pattern framework can be automatically applied to a domain model to create the infrastructure of a complete application. This process can be used iteratively to implement code changes through business model changes while preserving previous code extensions. We will investigate how this separation of concerns between application and architecture can ensure a consistent and maintainable application.
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.
Building Web Applications with the Tapestry Framework by Eitan Suez Tapestry is an elegant and powerful framework for building web applications. This session will introduce you to building web applications using Tapestry. The roots of this framework and its philosophy will be discussed. One major goal of the Tapestry framework is to provide an object-oriented model for the web, which in turn promotes simplicity and flexibility in web applications. Second, Tapestry is inherently designed to provide scalability in the web tier transparently. One of my favorite quotes from a developer who has used Tapestry is "Tapestry frags the snot out of frameworks like JSF, Struts, and the like." Come see for yourself what the hype is all about.
Integrating Castor into your Java developer Toolset by Eitan Suez Castor is an open source data binding framework for Java." In this session, Eitan will walk you through all about Castor, why you should use it, and how it simplifies your job as a software developer. The two principal components of this open-source framework are Castor XML and Castor JDO. You'll learn how to apply Castor XML to various tasks including configuration, and how to effortlessly marshal your objects as XML over HTTP. Combined with Castor JDO, you'll discover how simple the task of serving content on the web becomes. Note: This is a 3 hour session with a 15 minute break.
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.
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 approach
Btter 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.
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.
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.
Introduction to Pragmatic Programming by Dave Thomas Software projects still run late, over-budget, and under-featured. Managers ask their developers to work insane hours anyway, all in the face of changing technologies and changing requirements. Walking on water and developing software from a specification are easy if both are frozen. But in today's business climate, everything is undergoing constant change; nothing is frozen.
Pragmatic Mock Objects by Dave Thomas
Introduction to Aspect-Oriented Programming and AspectJ by Glenn Vanderburg Aspect-Oriented Programming is a relatively new approach to solving some of the weaknesses of object-oriented programming. AOP doesn't replace OOP; rather, it complements OOP, melding with object-oriented designs to handle certain issues – certain *aspects* -- that objects don't deal with particularly well. This talk explains the principles of AOP, illustrates the problems it is intended to solve, and introduces the most popular aspect-oriented tool currently available: the Java-based AspectJ system.
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!
Project infrastructure best practices by Glenn Vanderburg When we talk about making development projects successful, people tend to focus on architecture and design techniques, modeling tools, new technologies and paradigms of programming, requirements gathering, and methodologies. But sometimes the difference between success and failure comes down to much more mundane issues, like project infrastructure. Source code control, bug and change management, build automation, test automation, project communication, code organization ... all of those things can have a surprising impact on your project. (And if they're done badly, that impact is something you could do without.) Come learn about the kinds of infrastructure that some of the best and most experienced teams use. We'll look at different kinds of infrastructure and why they're all important to a project. We'll also talk about various tools you can use, and their strengths and weaknesses.
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.
|