New York Software Symposium

July 8 - 10, 2005



Event Details

Location

Sheraton Newark Airport
128 Frontage Road
Newark, NJ 07114
View Map

NOTE: You are viewing details about a past event. You may view our upcoming event schedule here ».

Session Highlights

Don't miss your chance to attend more than forty education and solutions sessions:

  • Seating is Limited
  • In-depth Discussions
  • Peer Exchange
  • Access to Speakers
  • Expert Panel Discussions
  • Hands-on Code Examples
  • Best Practices
  • Birds of a Feather Session
  • Insight on Cutting-Edge Tools
Download Session Listing

Featured Sessions

Class Loading in Java: Building Dynamic Systems Wi..
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.

Class Loading in Java: Building Dynamic Systems Wi..
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.

Java Platform Security and JAAS
By Stuart Halloway

The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

AJAX: Creating Next-Generation, Highly Dynamic, Of..
By Ben Galbraith

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.

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, Ruby and C#. A quick introduction to the role AOP plays in changing the patterns landscape will also be covered.

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?

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.

Learn about how you can use Rules Engines in Java development to take care of complicated problems.

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!

Spring Security with ACEGI
By Justin Gehtland

Spring offers developers a simpler, more robust method for configuring applications. These benefits extend to security through the ACEGI framework. ACEGI makes the otherwise daunting task of securing your application logical and straightforward. More importantly, through its support for single sign-on provision through Yale's CAS system and its ability to provide instance-level authorization, Spring extends the common security model of most J2EE apps beyond what they are traditionally capable of.



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.

Java Transaction Management Part 1
By Mark Richards

Although Spring and EJB isolate 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 in Enterprise Java Applications. 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 both Spring and EJB support (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. Within this model we will explore some common pitfalls and look at the best practices within this model. Through coding examples in both EJB and Spring using real-world scenarios, you will learn how to properly handle exceptions, how to correctly use transaction attributes, and how the isolation level can affect transaction and application behavior. This session is the first part of a 3 hour transaction management session.

Regular Expressions in Java
By Neal Ford

Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.

Aspect-oriented Refactoring: Taking Refactoring to..
By Ramnivas Laddad

Refactoring allows reorganizing code while preserving the external behavior, while AOP facilitates modularizing crosscutting concerns in a system through use of a new unit of modularity called aspect. Aspect-oriented refactoring synergistically combines these two techniques to refactor crosscutting elements. Individually, refactoring and AOP both share the high-level goal of creating systems that are easier to understand and maintain without requiring huge upfront design effort. A combination of the two -- aspect-oriented refactoring -- helps in reorganizing code corresponding to crosscutting concerns to further improve modularization that is easy to understand, highly consistent, and simple to change.

View All Sessions »