Research Triangle Software Symposium 2005 Hilton Research Triangle Park www.nofluffjuststuff.com/2005-06-raleigh/index.jsp
The No Fluff Just Stuff Software Symposium 2005 tour is pleased to
announce the return of the Research Triangle Software Symposium coming
to RTP on June 10-12th. You will have the opportunity to attend the best technically
focused Java event anywhere. We make this claim based on the following:
1). Excellent Speakers with unparalleled access by attendees 2). Limited Attendance = 250 Registrants Max 3). No Vendors, No Sales Pitches, No Marketecture 4). Unmatched Value – less than 1/3 of the cost of a national conference 5). Since 2002, we have hosted over fifty (55) software conferences throughout the U.S. and Canada with over 8,500 attendees.
The No Fluff Just Stuff Software Symposium Series caters to individual
developers, development teams, technical project managers, architects
and independent consultants. The Research Triangle Software Symposium
will offer five (5) concurrent sessions over three days for a total of fifty-five
(55) sessions to choose from. RTSS 2005 will feature presentations on
the following topics:
* Core Java * Client Side Java * ServerSide Java * Architecture * XML * Web Services
Featured Speakers include: Jason Hunter, author of "Java Servlet Programming" Dion Almaer, former Editor-in-chief of TheServerside.com Bruce Tate, co-author of “Better, Faster, Lighter Java” Ted Neward, author of “Effective Enterprise Java” Dave Thomas, co-author of “The Pragmatic Programmer” Justin Gehtland, co-author of “Spring Developer's Notebook” Stuart Halloway, author of "Component Development for the Java Platform"
Registration Fee: Individual: $675 special early bird discount valid thru May 23rd or whenever we sell out. An additional $50 discount is available to all JUG members for individual registrations thru May 23rd. Please use the discount code, nfjs2005spec when registering.
Group Rates: (Valid thru 5/23/05) 5-9 Attendees: $600/person, after $675 10-14 Attendees: $575/person, after $650 15-24 Attendees: $550/person, after $625 25-over Attendees: $525/person, after $600
The Registration Fee includes the following: 1). All Access Pass to the three day symposium 2). Handouts from all sessions attended w/binder 3). CD with all presentational content @ registration 4). Custom NFJS Laptop/Backpack
Venue = Hilton RTP @ $89/night
Go to www.nofluffjuststuff.com/2005-06-raleigh/index.jsp for more details.
Questions/Comments: Contact Jay Zimmerman: [EMAIL PROTECTED] or (303)469-0486
************************************************************************************************************************************************************ Research Triangle Software Symposium 2005 -Session Schedule-
June 10, 2005 12:00 – 1:00 PM: Registration
1:00 – 1:15 PM: Welcome/Overview
1:15 – 2:45 PM:
Session #1: Applied AOP by Brian Sletten
Most people new to Aspect-Oriented Programming (AOP) are fed up with separation of concerns zealots explaining how great their techniques are at dealing with... logging. Ok, you get it. Logging is a cross-cutting concern that can be appropriately modularized. What else does AOP have to offer? A lot, it turns out. This talk will give an introduction to the motivations of AOP as well as a series of concrete examples drawn from enterprise and client side Java. Come learn how AspectJ-flavored AOP can begin to benefit you immediately either in development or production environments. Learn how to enforce architectural policies, find Swing threading issues, reduce the invasiveness of the Observer design pattern or even improve the reusability of your domain models.
Session #2: Cryptography for Programmers by Stuart Halloway
For centuries people have used crypto to build (and break) secure systems. Computers have only raised the pitch of conflict, providing enormous cryptographic power at commodity prices. Most programmers do not write their own crypto libraries, instead relying on the services of an operating system or virtual machine. But even with all this support, building secure systems is a daunting task. This talk will cover three things all programmers need to know:
1. the basic tools of computer crypto
2. the programmatic APIs to these tools
3. common programming mistakes that can undermine otherwise secure systems
You will learn the basics of hashing, message digests, public key encryption, symmetric key encryption, certificates, and key management. With each, you will see programmatic examples, with advice for correct usage.
Session #3: OpenSource Ecosystems by Dave Thomas
Open Source communities produce high quality software with little management and (typically) no pay. Most people looking at open source focus on using this software in their projects. This talk takes a different tack: how can we bring the open-source way of developing software into our corporations, improving the way we write software? It turns out the answer has a lot to do with people, and a lot to do with agile software development.
Session #4: Spring Overview by Bruce Tate
The Spring framework is one of the fastest growing open source frameworks. New job postings are gaining rapidly, and many customers are adopting Spring instead of heavier alternatives. In this session, we’ll introduce Spring. You’ll see how Spring can give you much of the power of EJB, without the complexity or pain. Spring uses concepts like dependency injection and aspect oriented programming to ease standard enterprise development. Spring developers write plain, ordinary Java objects (POJOs), instead of sophisticated components.
Session #5: Creating Polished Swing Applications by Ben Galbraith
Too often, Swing applications are slow, ugly, and hard-to-maintain. It turns out that it doesn't have to be this way. Swing can be used to create highly-responsive, beautiful applications that are very maintainable. If this isn't consistent with your own experience, don't feel bad; its not very obvious how to make Swing sing. In this session, I explore three topics that lead to much better Swing applications:
- Proper Swing threading - High-quality third-party Swing look-and-feels - Good practices for coding Swing applications
In the threading portion of the session, I explain Swing's event handling architecture and its implications for Swing applications. Understanding this topic is crucial to creating highly-responsive Swing apps. I demonstrate how to use this knowledge in the form of many live-coded examples, and I show how frameworks like SwingWorker and FoxTrot can make this easier. Java's default look-and-feel, Metal, is awful (and in my opinion, the "Ocean" theme in JDK 5.0 doesn't do enough to improve it); you should stop using it immediately. But creating good-looking applications is sadly more than slapping in a look-and-feel; you must also take care to understand the principles behind attractive layouts. I spend the second part of this session exploring how to make your Swing applications look great through a combination of third-party look-and-feels and layout techniques.
2:45 – 3:15 PM Break
3:15 – 4:45 PM
Session #6: Ruby for Java Programmers by Dave Thomas
Ruby recently enjoyed its tenth birthday. Instead of cake and candles, the community celebrated by releasing a wave of new libraries and frameworks that make Ruby programming even easier. This talk features some of the best of these, as we explore Ruby and the web. If you can't help thinking that there must be an easier way of developing web projects, come and join us as we construct an MVC-based Ruby application using the very latest libraries and tools. You'll get a taste of Ruby, and also a feel for some of the power and productivity gains offered by this remarkable language.
Session #7: Principles of Service Oriented Architectures by Justin Gehtland
SOA (Service Oriented Architectures) are the logical inheritor to the Enterprise Application Integration throne. As distributed applications begin to span more than just multiple servers, but multiple application servers, platforms, networks and transport protocols, the techniques for integrating the components together must change. Service Oriented Architectures are based on the notions of open messaging protocols, publishable interface contracts and shared standards. This session is for people who want to understand, from an architectural level, what it means to be "service oriented". We won't look at much code, but we'll look at a lot of pictures of applications and how they interact. We'll learn how "service oriented" differs from "enterprise integration" and learn some of the new assumptions and requirements in this new architecture. You will also learn why the industry has landed on SOAP and XML as the primary messaging platform.
Session #8: Making the Most of XML by Ben Galbraith
For many of us, XML has become a ubiquitous presence in application development, whether parsing, validating, or manipulating it. For many of us, all that XML is coupled with pain, in the form of tedious APIs (like, say, the W3C DOM API) and confusing technologies (oh, I don't know, W3C XML Schema?). In this session, I share the following tips for making the XML in our lives a little easier to deal with:
- Use StAX instead of SAX - Use StAX to create XML - Use JDOM instead of W3C DOM - Use XPath to select XML - Use Jaxen to enable XPath over custom trees - Use RELAX NG instead of DTD or WXS - Use Trang when DTD/WXS output is required - Use Sun's RELAX NG Converter when WXS input is required - Consider RELAX NG's compact syntax - Use Schematron to extend schema languages - Consider XML namespaces for versioning - Ignore unknown namespaces
Session #9: Lightweight Development Strategies by Bruce Tate
Based on the book Better, Faster, Lighter Java, this session will show the average enterprise Java developer why current technologies are inadequate. The session will focus on these basic principles:
A). Traditional object oriented development may work for large projects, but it’s not the right approach for most of the enterprise software that we build.
B). Certain characteristics of technology can improve your chances of success.
C). Some new open source technologies, like Spring and Hibernate, dramatically simplify programming by reducing complexity.
Many development teams use heavyweight development technologies to solve basic problems. We overuse EJB, we use XML where it’s not the best fit, and we needlessly complicate our lives in many other ways. We’ll look at process, architectures, and technologies that can simplify your code and save you money. When the session is over, you’ll have a good understanding of the techniques that you can use to do lighter-weight, simpler development projects. You’ll know the processes that the experts favor, and the tool kits that they use to simplify their lives.
Session #10: Applied Design Patterns by Brian Sletten
Just about every modern software developer has a copy of the Gang of Four "Design Patterns" book sitting on a shelf; many of them have actually read it. The dark secret of the patterns community is that there is often a large gulf between whiteboard simplicity and real-world complexity. Language choice plays a part in the design (and even importance) of patterns. The situation is made even more confusing by the fact that many of the core patterns have now been "voted off the island" for one reason or another. This talk will give a pragmatic overview of the motivations behind design patterns and will focus on applying a handful of the GOF patterns to example scenarios in Java and C#. A quick introduction to the role AOP plays in changing the patterns landscape will also be covered.
4:45– 5:00 PM: Break
5:00 – 6:30 PM
Session #11: Creating Killer Graphics and Professional PDFs with XML 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.
In this session, I 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 #12: Writing Secure Web Services (with Axis) by Justin Gehtland
Web Services are message-oriented. This means that any application intention (the need for security, for transactionality, for reliability, etc.) must be included in the message and not just assumed as external context. The WS-Security specifications are very advanced and currently being used in the wild to create robust, secure web services. This session will examine these specifications, including:
• WS-Security
• WS-Policy - for sharing enforcement and encryption strategies
• WS-Privacy - for agreeing on privacy policy for service usage
• WS-Encryption - for encrypting or signing all or part of a message
• WS-Trust - for creating a single-sign-on solution
• WS-Federation - works with WS-Trust
These specifications, plus others like WS-Addressing and WS-Notification, provide a platform for communicating security intent across multiple network layers and many platforms. Of course, these specifications only define modifications to the message; the implementation of the features is left to the application author. We will demonstate these capabilities using the Axis toolkit and the J2SDK.
Session #13: Ruby on Rails by Dave Thomas
The Ruby on Rails framework has exploded onto the scene over the last few months. Propelled by some genuine benefits, and fueled by a whole
lot of controversy, Rails seems here to stay. So, is it a Java killer? (No.) Is it a great way to develop certain classes of web
application? (Yes.) Does it really deliver the 10-fold increase in developer productivity that some have claimed? (It depends...)
If you can't help thinking that there must be an easier way of developing web projects, come and join us as we construct an MVC-based
Ruby on Rails application using the very latest libraries and tools. You'll get a taste of Ruby, and also a feel for some of the
power and productivity gains offered by this remarkable framework. You'll need a grounding in Ruby to get the most from this talk; if you're not already a Ruby developer you might want to attend the Facets of Ruby talk before coming to this one.
Session #14: Taking Quality to the Next Level through Code Coverage Analytics by Andrew Glover
You’ve drunk the XP cool-aide and made a concerted effort to actively unit test your code. After awhile, however, you may find yourself wondering how good are those tests? Are they actually covering the code adequately? Understanding what code coverage represents, how to effectively apply it, and how to avoid its pitfalls will give you an unprecedented understanding of how those unit tests may or may not be covering you from sneaky defects. We’ll talk code based coverage and specification-based coverage and we’ll look at the tools available to gather these metrics in both the open-source and commercial worlds. Additionally, we’ll examine the notion of mutation testing and its affect on code coverage.
Session #15: The Politics of Persistence by Bruce Tate
This free-form session is intended to help attendees choose or validate a persistence framework. In it, the instructor will take questions from the audience, and tailor the session to the questions asked. Bruce will focus on three persistence frameworks: EJB, JDO and Hibernate. He’ll talk about the evolution of each of the frameworks. He’ll talk about the fundamental design philosophies of each, and what makes each unique and strong. But understanding technical strengths is not enough in the area of persistence. To make the best possible choice, a developer or architect must also understand the politics of persistence, and the marketing pressures that lead to the success or failure of each framework. The proposed common standard across JDO and EJB will get special consideration. This format has been very popular among nofluffjuststuff attendees. It’s highly tailored to each audience, but still flows with good structure. When the session is over, you’ll have a better understanding of the major persistence frameworks in the Java space, and what makes each valuable. You’ll also understand how much of a role market share and technology play in the success or failure of a persistence framework.
6:30 – 7:15 PM Dinner
7:15 – 8:30 PM: Keynote by Dave Thomas, “Art in Programming”
Research Triangle Software Symposium 2005 -Session Schedule-
June 11, 2005
8:00 –9:00 AM: Continental Breakfast
9:00 – 10:30 AM
Session #16: Introduction to Hibernate by Justin Gehtland
O/RM (Object/Relational Mapping) seeks to eliminate repetitive or tedious work enabling the CRUD (create, read, update, delete) that underlies most applications. Hibernate is a popular, open-source O/RM tool that uses reflection (instead of code generation, like EJB, or bytecode injection, like JDO) to manage your persistence layer. This session will introduce you to Hibernate. After an overview of common usage scenarios, including web and enterprise applications, we'll examine the basics of getting Hibernate running. We'll cover the mapping file format and syntax, including common relational mapping structures. Then, we'll examine the Hibernate API for interacting with the framework. Finally, we'll cover the common architectural decisions you'll have to make as you include this (or any other) O/RM framework.
Session #17: Class Loading in Java: Building Dynamic Systems Without Pain by Stuart Halloway (3 Hour Session)
One of Java's greatest strengths is its flexible deployment model. In this session you will learn how Class Loaders facilitate deployment, and how to troubleshoot Java and J2EE Class Loading problems. We will begin by looking at the basic class loading model provided by the java launcher, including the classpath, extensions path, and bootstrap path. Next, we will see how J2EE, Ant, browsers, and other container applications extend this model, using SecureClassLoader and URLClassLoader to dynamically load new classes at runtime. These techniques allows side-by-side deployment of multiple versions of the same class, and redeployment of changed classes without shutting down the Java virtual machine.Java's class loader architecture provides a dynamic and extensible mechanism for building applications. You will learn how to use class loaders to deploy multiple versions of classes side-by-side in the same JVM, and how to redeploy components withtout shutting down servers. You will also learn how to troubleshoot class loading problems such as inversion. You will learn to use the context class loader to correctly implement factory methods, and how to load non-code resources.
Session #18: Comparison of Lightweight Containers by Bruce Tate
Lightweight containers let you build a sophisticated application, with plain old Java objects (POJOs), and looser coupling than traditional alternatives. With the proliferation of new lightweight containers like Pico, Spring and Hive Mind, choosing an alternative can be daunting. This session shows why you would choose one framework over the others. These containers may be similar on the surface, but they are fundamentally different in several approaches. This session will start by showing you code for each of the containers, and compare the approaches. The examples will be very simple. Then, the session will show how services are integrated. Finally, you’ll see an overview of the unique features that each of the containers brings to the table. You’ll notice some similarities, and some striking differences:
Session #19: SWT Fundamentals by Ben Galbraith
The Eclipse project'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 a complex (and often obtuse) API, SWT relies on the host operating system for widget rendering and sports a simple, clean API. If your goal is to create a Java application that "looks" like a normal Windows application (or OS X, or Linux), SWT will revolutionize your world.
In this session, I introduce SWT from the ground up. I start at a high-level, but quickly move into the details of SWT's API. By the presentation's end, attendees will have a solid understanding of SWT, including:
- How to write a Hello, World SWT application
- How to use SWT layout managers
- Understanding event handling in SWT (including how to make applications as responsive as possible)
- Using SWT's advanced widgets
Session #20: Introduction to TestNG, the Next Generation Testing Framework for Developers by Andrew Glover
No one will argue the positive effects JUnit has had on the quality of thousands of Java applications around the world. JUnit's simplicity and ease
of use ushered in a whole new era of code quality; however, as many developers have found, its simplicity has also limited its use. TestNG was
designed from the ground up to overcome some of JUnit limitations..."
10:30 – 11:00 AM: Break
11:00 – 12:30 PM
Session #21: Advanced Hibernate by Justin Gehtland
Hibernate is easy to get started with, but can sometimes be hard to make efficient or secure. In fact, the default settings for Hibernate create applications that will run slowly, cause unwanted round trips to the database, and may be more restrictive and/or permissive from a security standpoint than you would otherwise want. This session will show advanced techniques for tuning performance, including:
• advanced collection mapping strategies
• lazy loading
• cascading update management
• lifecycle management
• Hibernate's interceptor layer
In addition, we'll examine the security considerations when using Hibernate. Often, single-credential data access isn't enough for sensitive data. We'll walk through using per-user credentials for data access, logging security information about and through Hibernate, and accessing data sources through secure application servers.
Session #22: Class Loading in Java: Building Dynamic Systems Without Pain by Stuart Halloway (Continued)
Session #23: Advanced SWT and JFace by Ben Galbraith
This session picks up where SWT Fundamentals leaves off. Among the advanced topics I discuss are creating custom SWT widgets and exploring tight native integration. I combine another compelling topic with the advanced SWT material: JFace. SWT is a more akin to AWT than Swing; its concerned more with wrapping native functionality than providing any high-level abstractions. JFace is an API on top of SWT that provides such abstractions. The combination of SWT and JFace is comparable to Swing. My coverage of JFace includes an introduction to several of its frameworks, such as the Viewer and Window frameworks, along with many examples. Learning JFace will enable you to write complex SWT applications much faster.
Session #24: 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.
Session #25: Beyond Java by Bruce Tate
The Java programming language has been tremendously successful. Many of the roots of its success may be surprising to the audience. But every major programming language has a limited life cycle. While it’s true that Java and .NET seem to be the only games in town, some alternatives are beginning to emerge. In this session, we’ll discuss some of the limitations of the Java language, and the impact that they might have on the productivity of Java developers. We’ll then look at some of the innovations around other frameworks and languages, and some of the features of those languages that boost the productivity of other non-Java developers:
• Typing, and why it matters • Code blocks and closures • Regular expressions • Innovative frameworks
12:30 – 1:15 PM Lunch
1:15 – 2:15 PM Expert Panel
2:15 – 3:45 PM
Session #26: The Fallacies of Enterprise Systems (Architecture) by Ted Neward
There's a set of fallacies that every enterprise developer has fallen for at some point in their enterprise development lives, and
unless they've come to realize it early enough, all cause big trouble and painful learning experiences in the long run. In this talk, we'll go over the Enterprise Fallacies, discuss why they're so insidious and easy to fall into, and how developers can go about making sure they avoid them in the future. Discussions will be relative to both .NET and Java, as well as the emerging Web services stack, as the Fallacies know no technical boundaries.
Session #27: Java Metadata by Jason Hunter
Java's new Metadata facility introduced in J2SE 5.0 defines a way to attach decorations to classes, fields, methods, and even packages that
can be extracted by the compiler or runtime tools to provide advanced functionality. Think of metadata as an extended @deprecated flag, or
think of XDoclet++. In this tutorial session you'll learn how Metadata fits in the Java platform (and how it compares to the C# platform). We'll cover how to use the metadata attributes provided in the core J2SE libraries and how to write your own. We'll also show a bit of what's coming in JSR-181, tasked to define standard metadata attributes for web services.
Session #28: Enterprise AOP by Dion Almaer
Aspect-oriented programming (AOP) has become a hot topic for enterprise development, with recent news of support by IBM, JBoss, BEA, Oracle, Eclipse, and IntelliJ. Behind the news headlines, however, are critical questions: How real is AOP for the enterprise? What problems can it solve today? How does it apply to enterprise applications? How can one make an informed decision about trying to use AOP? What is the best adoption strategy? What are the long term possibilities for AOP in the enterprise?
This session tackles these questions and show developers, architects, and technical managers how AOP can be used for enterprise Java application development. We provide a refresher of AOP concepts and show enterprise examples of how AOP works and where it can be beneficial, as well as discussing anti-patterns (i.e., how not to use AOP). Examples discussed include error handling, policy enforcement, tracing, systems management with JMX, and more. The examples are implemented in the AspectJ programming language (a popular and seamless aspect-oriented extension to Java) and incorporate major J2EE technologies such as servlets, JSPs, and EJBs. We will also demonstrate using the AspectJ tools to work in an enterprise environment. At the end of the tutorial, participants will have a better understanding of both the potential and the pitfalls for applying AOP in a J2EE context. The tools used in the tutorial are all freely available as open source software, so participants will be able to use the techniques shown in their own projects.
Session #30: Advanced Swing: Architecture and Frameworks by Ben Galbraith
Are you spending more time plumbing your Swing applications than solving business problems? Has your Swing application grown out of control? This session is for you. In the first part of the presentation, I analyze the architectural problems that plague many Swing applications and present architectures that overcome these problems. These architectures are presented in terms of principles along with a reference implementation. You can therefore either adapt the principles to meet the needs of your existing applications, or incorporate the specific ideas of the reference implementation into your new projects. Fortunately, there are some existing frameworks that have done some of the architectural work already. I present some of these frameworks in the rest of the presentation.
3:45 – 4:00 PM Break
4:00 – 5:30 PM
Session #31: Creating Next-Generation, Highly Dynamic, Off-line Capable Web Applications with HTML and JavaScript by Ben Galbraith & Dion Almaer
As recent high-profile web apps such as Google's GMail have shown, modern browsers are capable of natively rendering web apps with highly dynamic and compelling UIs - fetching server data without page refreshes, animating and manipulating page contents on-the-fly, even offline use. The line between web and "desktop" apps is blurring. Experienced web developer Dion Almaer (editor of TheServerSide.com) and noted Java desktop expert Ben Galbraith will describe and demonstrate these new techniques, including how to adapt modern web frameworks such as JSF and Tapestry to ease both the creation and maintenance of these types of applications.
Session #32: Effective Enterprise Java: Security (Java) by Ted Neward
Security's become a hot topic among enterprise developers in recent years, but to many developers, security is still the white elephant in the middle of the room. Discussions about security usually begin with, "Uh, we'll worry about that later", or, "Start with two really large prime numbers.....". Security isn't as hard as developers make it out to be, but it is something that developers need to face and recognize. In this talk, we'll extract the 10 Items on Security from Effective Enterprise Java and talk about them, giving developers the basic heads-up they need to have when building enterprise systems in Java.
Session #33: Extreme Web Caching by Jason Hunter
Web Caching is very important for high traffic, high performance web site but few people know all the professional-level strategies. In this talk I'll share some of the tricks of the trade, including advanced tips from Yahoo's Mike Radwin. We'll start with the basics: using client-side caches, conditional get, and proxies. Then we'll talk about more advanced features: how best to handle personalized content, setting up an image caching server, using a cookie-free domain for static content, and using randomization in URLs for accurate hit metering or sensitive content.
Session #34: 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.
Research Triangle Software Symposium 2005 -Session Schedule-
June 12, 2005
8:00 – 9:00 AM: Continental Breakfast
9:00 – 10:30 AM:
Session #36: An Introduction to XQuery by Jason Hunter
XQuery is a new language from the W3C that lets you query and manipulate XML -- or anything that can be represented as XML, such as
relational databases. As a Java developer -- especially a server-side Java developer -- XQuery is key to searching and manipulating large
XML repositories or performing any XML-centric task. This talk introduces XQuery. I'll explain the XQuery language; I'll show how to call XQuery from Java; and as the creator of JDOM, I'll also explain when to use XQuery instead of JDOM, and when to use both. Attendees should have an interest or need in managing large sets of XML, but need not have any past experience with XQuery. After the session, attendees will be able to program XQuery and know which implementations to trust.
Session #37: Cascading Style Sheets: a Programmer's Perspective by Eitan Suez
Today, the Cascading Style Sheets (CSS) specification is well supported by the major browsers (Mozilla, Safari, IE). CSS has become a practical tool for web content publishers that has helped turn heavy, buggy, and hard-to-maintain web sites into lean, clean, and stylish ones. CSS is sometimes stereotyped as a technology geared for graphic designers and artists. I beg to differ: I see CSS as a refactoring tool for content publishers and one that encourages content to become more strongly semantic. Come see a developer's perspective on CSS and how it can be applied to refactor your web content.
Session #38: Give the DB a break!: Performance and Scalability by Dion Almaer
What do we really mean by "performance" and "scalability"? This talk gets into the meat of problems which cause our applications to degrade. We will focus on issues such as problems caused by the database being a bottleneck for our application, and see how we can architect our solutions to bypass the issues, resulting in a solid system which scales with the increased load. Not only will we look at the factors, but I will delve into a couple of case studies to show how real world problems were solved!
Session #39: Java Collections Power Techniques by Glenn Vanderburg
The Java Collections framework is a cornerstone of Java development. It’s been a part of J2SE for six years now. Every Java developer knows it—how to create Lists, Maps, and Sets, how to put things into them and take things out, and how to iterate over the contents. But there’s a lot more to the collections framework than that. The basics of the collections classes are so simple that many developers haven’t even thought to look for the additional power that’s there. And it’s not just built-in capabilities, either. The design of the collections framework makes possible several powerful techniques and patterns that can magnify your productivity, as well as helping you build systems that are efficient and scalable.
Session #40: J2EE Transaction Management: Techniques and Best Practices - Part I by Mark Richards
Although the EJB container isolates us from most of the complexities involving transaction management, there are still a number of things we need to be aware of when dealing with transactions within the J2EE container. Too often transaction management is an afterthought in the design and development process, which leads to applications that have problems with data integrity, data consistency, and overall stability and reliability. In this session we will explore the three transaction models that J2EE supports (Local, Programmatic, and Declarative), and discuss the advantages, disadvantages, and pitfalls within each of these models, when it makes sense to use each transaction model, and under what situations these models are appropriate and inappropriate. We will spend most of our time on the Declarative transaction model, otherwise known as container managed transactions (CMT). Within this model we will explore some common pitfalls and look at the best practices within this model. Through coding examples and real-world scenarios, you will learn how to properly handle exceptions, how to coordinate multiple resources, how to correctly use transaction attributes, and how the isolation level can affect transaction and application behavior. We will also discuss the problems encountered with Entity Bean data caching and data synchronization within the context of JTA transactions. This session is the first part of a 3 hour session.
10:30 – 11:00 AM Break
11:00 – 12:30 PM
Session #41: XQuery By Example: Advanced Web Publishing by Jason Hunter
In this session I'll take some O'Reilly book content (encoded in Docbook XML) and show various ways that the content can be repurposed and made to sing and dance online using XQuery. I'll show several code scripts each less than a page long that do something interesting -- like combine chapters from various books to produce a dynamic table of contents or index, extract figures and graphics, perform targeted search, and print on demand.
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.
Session #43: Rules Engines by Dion Almaer
Rules Engines are powerful beasts which allow you to program in a way in which you specific rules and facts, rather than a linear set of instructions. It takes awhile to get used to "Thinking in Rules", but it gives you immense power for particular logical problems. You pass control HOW the rules are applied to the rules engine, and just give it the information it needs to get the job done.
Rules based systems are often great solutions for enterprise problems, and are uniquely useful for building so-called "business rules". Now you have an external view of your business, and can change behaviour via the rules rather than hard coding your application. Learn about the power of Rules based thinking in this talk, as we go through and show real examples of how it can help you out in your daily toil.
Session #44: Naked Objects Applied by Eitan Suez
Join Eitan in this hands-on session on Naked Objects. This session uses the "learning by doing" approach to learning an API or framework. Naked Objects is a powerful tool that can give you a significant advantage in the development of business systems. It gives you the ability to prototype a software application so quickly that it can be performed during information gathering phases of a project. It gives you the power to codevelop the core business model of your application with a non-developer business expert at your side. No prerequisite knowledge of Naked Objects is required.
Session #45: J2EE Transaction Management: Techniques and Best Practices - Part II by Mark Richards
This session is the second part of a 3 hour transaction management session. In this session we will explore some of the more advanced features of J2EE transaction management. We will pick up where we left off from the first session by taking a detailed look at XA and J2EE distributed transaction processing, and how to coordinate multiple resources within a single business transaction. Within the XA discussion you will learn what XA is, what the relationship is between JTA and XA, when you should use XA within J2EE applications, and how to enable JMS and DBMS resources to run under XA. We will also explore XA Drivers, and discuss the many issues surrounding XA Drivers within J2EE. We will then look at several transaction strategy design patterns, and learn what the advantages and disadvantages are of these patterns and how to apply them. We will end this session with looking closer at the Local Transaction Model, where this model breaks down, and the steps involved in converting from a Local Transaction Model to a Declarative Transaction Model.
12:30 – 1:15 PM Lunch
1:15 – 2:15 PM Birds of a Feather Sessions
2:15 PM – 3:45 PM
Session #46: Groovy by Dion Almaer
Groovy is an agile, dynamic programming language for the Java Virtual Machine. Groovy includes language features found in Python, Ruby, and Smalltalk, but uses syntax natural to developers that use the Java programming language. Because Groovy is based on Java 2, applications written in Groovy can use the full complement of Java 2 APIs, and work seamlessly with other packages and applications written in the Java programming language. The Groovy JSR will make the Groovy the next standardized programming language for the Java Virtual Machine. This tutorial introduces you to Groovy programming language and explains how it in to solve a variety of problems.
Session #47: Introduction to Web services, 2005 edition (Architecture) by Ted Neward
WSDL, and Schema and SOAP, oh my! It's 2005, and the Web services landscape looks even more confusing than it did two years ago, despite all sorts of promises to the contrary. What's it all mean, and how the heck did we get here when the original goal was to try and keep it all simple? In this talk, we'll go over the Web services landscape, examine the prominent and popular (SOAP, WSDL, Schema) specifications, look over the less well-known but important (WS-ReliableMessaging, WS-Addressing, and more) ones and talk about why they're important, and lay out a list of the losers (WS-Routing, WS-Referral) and why they haven't made the cut. When we're done, we'll examine them all in the harsh light of day and discuss which ones developers really need to care about, and which ones they can safely ignore, either for now or for good.
Session #48: The State Machine Compiler by Eitan Suez
Classes will often bear various states. Examples include a user who may be "logged in" or "logged out," a bill that is "open" or "paid," or potentially a more complex situation where an object obeys a set of complex rules that determines which of a number of possible states that object is in. The Gang of Four gave us the State Pattern, a fairly straight-forward mechanism for developers to model and implement the behaviour of stateful objects. The State Pattern is only the beginning of the story. Robert Martin developed the State Machine Compiler and has taken the job of developing and maintaining stateful systems to a new level. Today, SMC is a well-maintained open source project hosted on sourceforge.net. Come learn about SMC, a fundamental tool for implementing stateful classes and systems that every software developer should have in his toolchest.
Session #49: JavaScript Exposed: There's a Real Programming Language in There! By Glenn Vanderburg
JavaScript got a bum rap. It’s almost universally derided among “serious programmers” for being a “toy language,” or for its strange characteristics, or bugs, or slowness, or because it’s “only good for adding useless window dressing to web pages.” In this talk, we’ll go back to the basics that most JavaScript resources omit. We’ll talk about JavaScript as a language, learning its fundamental concepts and the simple rules that underlie the sometimes bewildering behavior. We’ll learn about JavaScript’s unusual object model, how to use it to build conventional object-oriented systems, and also how to exploit it more completely to do things you'd never think of doing in Java. We’ll also learn some good ways to structure large JavaScript programs. This talk is not about fancy web pages. It’s about a powerful tool that can be used for fancy web pages, but that’s also cropping up in many other places. It’s worth your time to learn it well.
Session #50: Hibernate and J2EE Transaction Integration by Mark Richards
Hibernate is quickly becoming a viable alternative to the EJB Entity Bean and DAO persistence models. More and more applications are being written using Hibernate, and many existing applications are replacing legacy Entity Bean or DAO persistence models with Hibernate. Hibernate has it's own transaction manager and transaction API that is simple to configure and use for single resource, web-based applications. However, things get a bit more complicated from a transaction standpoint when you consider using Hibernate as the persistence model for larger server-based J2EE Enterprise Applications. In this session we will take a look at how the Hibernate transaction model works and how to integrate Hibernate into the JTA transaction model within J2EE. We will look at both single resource coordination and multiple resource coordination, and how to manage transactions outside the scope of Hibernate. During this session you will learn the details of the Hibernate transaction model and how to integrate Hibernate into J2EE with both a single resource and multiple resources using XA. We will look at integrating Hibernate into J2EE applications using three J2EE transaction strategy design patterns; the Client Transaction Control pattern, Server Delegate Transaction Control pattern, and Service Transaction Control pattern. By the end of this session you will learn how to develop a robust global JTA transaction design strategy for large-scale J2EE applications using Hibernate as the persistence model for database resources.
3:45 – 4:00 PM Break
4:00 - 5:30 PM
Session #51: Seaside: a Radical Web Framework by Glenn Vanderburg
Seaside represents a new generation of web frameworks. Using it, web development is simple. A little code goes a long way. The code is simple and clear. There are powerful development tools that magnify your productivity. You can focus on making your web application good rather than having to strive with all your might just to make it work. It might not be perfect for your situation—it’s written in Smalltalk, for one thing, which presents a barrier to adoption in many organizations. And it’s not quite as scalable as more traditional web frameworks. But for most applications, it would drastically reduce the development effort while also increasing the usefulness and robustness of the application. Sound too good to be true? Yeah, I thought so too. But it is true. In this talk, we’ll see an extended demo of Seaside, and all the things that make it special. We’ll discuss how it works, as well as its limitations. Finally, we’ll look at other frameworks that are trying to bring the same ideas and techniques to other languages. Whether you try Seaside or not, a better way of developing web applications is in your future, and Seaside is showing the way.
Session #52: Forgotten Algorithms II by Jason Hunter
In this sequel to the popular Forgotten Algorithms talk, I'll explain -- without any needless math or boring proofs -- several fun algorithms. Each algorithm was selected because it's really practical, really interesting, or both. The algorithms are known to change but should include: public key crypto, two's complement, credit card checksum validation, priority queues, an XOR swap, and Google's MapReduce function for massively distributed calculation.
Session #53: Working with Java Metadata (Java) by Ted Neward
As part of JDK 1.5, Java has introduced a facility for developers to create and use custom metadata annotations, as developed by the JSR 175 committee. This represents a radical new shift for the Java programming language, quite possibly larger and farther-reaching than generics or any other language feature. In this talk, see the syntax and usage model for Java annotations, both how to create them as well as to use them in your code. We'll see different ways to find and consume the annotations declared on classes, including extensions made to the Java Reflection API as well as a new tool, "apt" (Annotation Processing Tool), for consuming annotations on source files. In addition, we'll discuss what annotations are best used for, and when they should be bypassed in favor of other approaches.
Session #54: XML Data Binding with JiBX by Eitan Suez
JiBX is an open source XML data binding API for Java. JiBX is younger than most other APIs in this space (Castor XML, BEA XMLBeans, JAXB). JiBX's philosophy on data binding is that: [a] databinding should be fast, and [b] databinding frameworks should allow for the divergence and evolution of your codebase from its xml representation. JiBX excels on both counts and consequently is a practical tool for the purpose of data binding. In this session, Eitan will be covering all aspects of Dennis Sosnoski's JiBX framework.
Session #55: A Pragmatic Look at Agile Architecture by Mark Richards
Designing application and enterprise architectures is a complex process. We follow defined processes, create lots of attractive architecture diagrams, kill lots of trees producing hundreds of pages of architecture documentation, and yet we find that in many cases the architectures we design are not followed by developers or simply not understood by the stakeholders or development community. As a result, either the delivered software does not match the original architecture, or the architect works 25 hours a day to ensure that the software is in compliance with the original architecture. We will then look at some Agile principles and see how we can apply these methods to simplify the architecture process and produce better ar
_______________________________________________ Juglist mailing list [email protected] http://trijug.org/mailman/listinfo/juglist_trijug.org
