Gateway Software Symposium
March 16 - 18, 2007 - St. Louis, MO
Pete Behrens - Organizational Agility Coach
Scrum is a very easy agile framework to understand, but is very difficult in practice. Why is that?
For one, Scrum requires compressing an entire software lifecycle into very short time increments of 2-4 weeks in length. It requires cross-functional team commitment, discipline, communication, and collaboration to accomplish their goals. These changes are difficult and often expose organizational and environmental issues that must be addressed for the team to be successful.
This session brings focus to the Scrum heartbeat - the sprint. After a brief introduction of the Scrum framework and a focus on the sprint, we will be taking an experiential hands-on journey through a full sprint with your newly formed team.
Are you overrunning your architectural runway? Many companies struggle with their ability to retain their architectural integrity when they transition to agile methods. Emergent Architecture (the other EA) can lead to cowboy coding and ad-hoc design decisions that emerge into a poor overall architecture.
Enterprise Architecture (EA) has been a tried and true approach to address these architectural needs throughout the organization, yet this approach often leads to a heavy-handed, document-rich, control-oriented culture lacking ability to keep pace with today's dynamic business environment.
Attempting to integrate an agile process with an Enterprise Architecture approach can be like mixing oil and water - they just don't work together. This session evaluates alternatives in balancing Agility and EA and proposes an architectural approach to build an Agile Enterprise Architecture into your organization.
Business leaders and stakeholders require accountability and accuracy in our software release projections and yet, as an industry, we have failed. However, many of these same leaders are not convinced that agile is any more than an excuse to avoid projections at all. While it is true that agility provides the framework to support change, it doesn't mean you can't provide accurate projections. In fact, a well-executed agile process actually provides more accurate results with less time investment than traditional methods. This session will demonstrate these agile project management techniques to manage 6-12 month projects.
This session focuses on the release level, followed by Part II which focuses on the sprint level.
User Stories, a key practice from Extreme Programming, provide a right-sized solution to more efficiently identify, track and implement product requirements. Learn how identify, write and decompose "good" user stories that drive agile behavior and business value.
"YAGNI (You Ain't Gonna Need It)" and "Doing the simplest thing possible" are mantras of agile development. A white board, sticky notes, and flip chart paper are by far the best tools for individual teams. However, when coordinating work across 10 - 50 teams across 12 time zones, more tooling is required. Learn how agile enterprises are leveraging tooling to manage their portfolios, projects and products.
Jeff Scott Brown - Core Member of the Grails Development Team
Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. Grails provides simple mechanisms for leveraging the power of Ajax.
Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring, Sitemesh and Quartz to make web application development both fun and easy.
Scott Davis - Author of "Groovy Recipes"
I'm attracted to Groovy because of its spirit of inclusiveness. Because it extends my platform of choice, not replaces it -- include a single JAR in your classpath and you are Groovy-enabled. Because it offers full bidirectional integration with Java. Because it offers a nearly flat learning curve for experienced Java developers. Come see how you can use Groovy to augment your existing Java codebase.
"Which framework should I use?" is the question most often heard on the No Fluff, Just Stuff tour. It's well worth asking. Unfortunately, there is no simple answer. After years on the tour, most speakers have crafted a response that would make any Washington politician proud -- long on style, but essentially, "Well, it depends..."
In this talk, we'll survey the web services exposed by leading websites (Google, Yahoo, Amazon, eBay) and discuss how they can be easily mocked up for testing purposes and to aid offline development. You'll see working examples of RESTful, SOAP, and JSON web services, as well as strategies for unit and functional testing your asynchronous, service-oriented architecture.
Scott Davis is the Editor in Chief of aboutGroovy.com. The website, in addition to being, umm, about Groovy, is implemented in Grails. This talk shows you how to get started with Grails, but also talks about the experience of using it in a live, production web site.
Google quietly deprecated their SOAP search API at the end of 2006. While this doesn't mean that you should abandon SOAP, it does reflect a growing trend towards simpler dialects of web services. Google joins a number of popular websites (Yahoo, Flickr, YouTube, del.icio.us) that offer all of the benefits of web services without all of the complexity of SOAP.
Scott Delap - Author of Desktop Java Live
This tutorial emerges out of the combined experience the presentor gained while working on a large Eclipse RCP/J2EE enterprise application (2.3 million lines of code in the RCP application). It will address the gap between the standard functionality of Eclipse RCP and what is needed for the creation of polished highly usable business applications.
Rich client application development using Java can be intimidating giving the vast flexibility in application design and structure. It also can be frustrating to create the large number of support services (persistence, menus, event and job frameworks) that a large scale rich client applications needs. The Eclipse Rich Client Platform is one project attempting to solve these issues by providing a core infrastructure that not only provides the day to day services a rich client application developer needs, but also providing a suggested path to guide you down the road of designing your application. This presentation introduces both the Eclipse RCP and the tools provided by the Eclipse IDE that assist developers in writing RCP apps.
Neal Ford - Application Architect at ThoughtWorks, Inc.
This session discusses advanced Selenium techniques for testing web applications. It discusses techniques for both TestRunner and Remote Control Selenium, including data driven tests, creating branch points, testing Ajax applications, creating flexible tests, integration with continuous integration, and tons more.
This talk avoids SOA hype and gets to the meat of the matter: how do you implement a Service-Oriented Architecture, what are the technological pitfalls, how do you test it, and what traps should you avoid. No marketecture: just implementation details.
This session discusses how to use the Productive Programmer principles of acceleration, focus, and indirection to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.
This session discusses how to use the Productive Programmer principles of automation and canonicality to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.
No one writes perfect code: even the best developers fall into bad habits and traps. These topics from The Productive Programmer illustrate blind spots and helps you write better code.
David Geary - Author of Graphic Java, co-author of Core JSF, member of the JSF Expert Group
JavaServer Faces is a perfect platform for implementing Web 2.0 interfaces with Ajax. This session explores how you can use these two potent technologies--JSF and Ajax--together to create applications that look and behave like desktop applications but run in the browser.
In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).
JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.
Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.
Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.
In this session, see how you can get Ruby On Rails-like productivity on the Java side of the house with this compelling combination of technologies.
A continuation of a 2-session presentation on Seam, Facelets, and Ajax4jsf.
The second part of a 2-session presentation on the Google Web Toolkit.
Stuart Halloway - CEO of Relevance
JRuby is not one, but two great technologies: the Ruby language, and the Java Virtual Machine and libraries. In this talk you will learn the basics of programming JRuby, and how to integrate JRuby code into existing Java projects.
Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.
Streamlined is a framework for automating user interfaces in Rails. Where ActiveRecord makes the "M" in MVC simple and declarative, Streamlined does the same thing for the "V" and the "C."
Jason Hunter - Author of Java Servlet Programming
In this talk I'll explain -- without any needless math or boring proofs -- several fun algorithms of interest to back-end web programmers. Each algorithm was selected because it's really practical, really interesting, or both. The algorithms aren't always the same but can include: public key cryptography, credit card checksum validation, TCP Slow Start, two's complement, priority queues, the XOR swap, and the Google MapReduce function for massively distributed calculation.
The new Java 5 release introduces a number of significant Java language enhancements: generics, typesafe enums, autoboxing, an enhanced "for" loop, a static import facility, and a general-purpose metadata facility. This talk gives an overview of the changes and helps you understand what all the funny new syntax means.
If we're moving toward Web 2.0, what does that mean for online publishing? In this talk I'll answer that question. Based on my experience as Principal Technologist at Mark Logic working with dozens of the largest online publishers, I'll present a vision for how the Web 2.0 concepts like personalization, collective intelligence, the long tail, and the importance of "owning the data" can and should reshape the face of online publishing -- and how XML, XQuery, and XML-aware text search act as the key enablers. I'll also introduce new Web Publishing 2.0 concepts like "Sweat the content" and "Give answers not links".
The Java 6 (Mustang) release should make your life easier, for a change. It doesn't alter the core language like Java 5 did. It doesn't pack in so many sub-JSRs that you'll be overwhelmed by the amount you have to learn. Instead Java 6 adds several handy things that honestly should have been added before. Among the improvements we'll cover in this fast-paced class:
- A new Console class
- A real Compiler API
- A GIF writer
- Pluggable Locale data
- Access to disk partition size data
- Array reallocation
- Low-level floating point functions
- Reflective access to parameter names
- Access to network interface details
- Pluggable annotation processing
- Improved class file format
- Streaming XML with StAX
- A new Scripting interface
The classic searchable email archive system is cluged together -- a frankenstein monster combining a relational database with a search engine, with Java just barely able to keep the two together. In this talk we'll demonstrate how email is more content than data, how it's better encoded in XML rather than relational tables, and how Java can convert emails to XML and drive an XQuery backend to produce a simpler and more scalable email archive system.
Scott Leberknight - Chief Architect at Near Infinity
Hibernate seems simple on the surface yet when you go beyond very simple use cases it can become much more complex. Intended for beginner to intermediate-level Hibernate developers, come see how to put Hibernate to effective use on your projects.
Hibernate is a very popular Java transparent persistence framework, but you often need to create additional infrastructure to manage sessions, transactions, and lazy-loading in a clean and elegant manner. See how Spring can help.
Using Spring's Hibernate integration significantly simplifies applications that use Hibernate for data persistence by removing tedious and repetitive infrastructural code that you need to write. Intended for developers familiar with Spring/Hibernate integration basics, who want to learn additional idioms and solutions to common problems.
Ted Neward - Enterprise, Virtual Machine and Language Wonk
If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.
Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to have some basic ideas about bug-tracking in your toolbox. Learn to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.
Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.
If you've never used Reflection (java.lang.reflect), you don't know what you're missing. In this presentation, we'll take a code-first, soup-to-nuts look at the Java Reflection APIs, from how to examine the class metadata that Reflection provides, to using annotations to enhance that metadata with your own information, even through the use of Java Dynamic Proxies to create flexible object "interceptors" that can layer services in front of ordinary method calls with nothing more complicated and an interface and a factory.
If you've been keeping your ear to the ground, you may have heard some talk recently about "rules", "business rules" and "rules engines", but not necessarily any clear discussion on what they are, how to use or design them, or why they might be useful or important.
Brian Pontarelli - Founder of Inversoft
Learn how to create software builds that will stand the test of time and make the world a better place - okay perhaps just your development environment a better place. Builds are usually the tedious work that we all leave to the last minute or sometimes throw together as we build an application. But in most applications, builds contain complex logic and many dependencies, just as the application does. This presentation covers how to make a manageable and enjoyable build system using Apache Ant and a new Ant framework that is part of the JCatapult platform called JCatapult-Ant.
The Java NIO packages that were added in JDK 1.4 and these packages allow Java applications to perform true non-blocking IO operations. This presentation will cover the basics of the standard IO packages, which date back to the beginning of Java, and some of the shortcomings they have. This will be followed by coverage of the newer NIO packages and how they address these issues.
This talk will cover many of the different types of SOA topologies from EJBs and WebServices all the way to message queues and tuple spaces. SOA has many different meanings but it never dictates a single implementation and this talk covers many of the most common implementations of a service oriented architecture.
Mark Richards - SOA and Integration Architect, Author of Java Message Service
This session picks up where the Intro to JPA session left off and covers some of the more advanced topics in the Java Persistence API. Some of the topics covered in this session include switching persistence providers, versioning, compound keys, entity inheritance, and finally handling both simple and complex stored procedures. Some knowledge of JPA is recommended for this session as I will not be covering the basics of JPA (that is covered in a separate Intro to JPA session). Through a combination of slides and interactive coding I will demonstrate these advanced topics using both Hibernate and Toplink JPA.
In addition to providing a simplified API, the new EJB3 specification (JSR-220) defines a standard ORM Java Persistence API (JPA) that is rapidly gaining in popularity. As you will see in this session, JPA bears a striking resemblance to popular ORM solutions like Hibernate and Toplink. In this session we will explore in detail the new Java Persistence API offered by JSR-220. We will start by discussing the overall design and architecture of the JPA and how the major components within JPA interact. We will then look at defining mapping objects (entities) and how to use the EntityManager to manage these entities. Through interactive coding examples we will investigate the pros and cons of detached entities and merging, how to map and use entity relationships (1-1, 1-N, N-1, and N-N), discuss Lazy Loading, and finally see how to use XML mappings rather than annotations. More advanced features of JPA will be covered in a separate session.
Java Persistence has come along way since the days of straight JDBC coding and custom framework development. We have at our disposal several outstanding open source frameworks such as Hibernate, Toplink, iBatis, and OpenJPA (just to name a few), and we now have a promising and emerging standards-based solution called Java Persistence API (JPA). However, all to often we find in the Java persistence space that it is a world of one-size-does-not-fit-all. We continually struggle with traditional ORM solutions like Hibernate when it comes to reporting queries, complex queries, complex relationships, and stored procedures, and we also struggle with managing the enormous amount of SQL required for solutions such as iBATIS or JDBC-based frameworks. In this coding-intensive session we will take a detailed look at identifying and overcoming the challenges we face when using frameworks such as Hibernate, iBATIS, and JPA, and how to combine the various persistence frameworks to create an effective Java persistence solution that approaches (but of course does not reach) the silver bullet.
There has been a significant amount of buzz in the community and industry about the definition and role of an Enterprise Service Bus (ESB), particularly within the area of Service-Oriented Architecture (SOA). In this product-agnostic high energy session we will take a step back and consider whether we really need an ESB. Through real-world application and architecture scenarios we will see where an ESB would be helpful and where it would be overkill. We will take a look under the hood and find out just what an ESB is really doing, and take a quick look at JBI (JSR-208) and see the impact it has on the ESB worls. Then, using product-agnostic coding examples we will learn what an Enterprise Service Bus is supposed to do, then answer the question about whether the ESB is just a bunch of hype or if we really need it.
Jared Richardson - Agile coach and co-author of Ship It
Creating and maintaining a solid automated test suite is critical to an Agile strategy, but often we're just told to "Do it." In this talk we'll look at several pragmatic strategies for creating and building your suite.
A great team builds great software, but how do you build a great team?
Agile practices are popular because they work, but getting people to take that first step can be tricky.
An overview of the Agile software approach from the book Ship It! A Practical Guide to Successful Software Projects.
Ken Sipe - Architect, Web Security Expert
You are using Java, whew!!! No need to worry about memory, the garbage collector will handle that. Those who have had a memory issue in Java are not so naive any more. Often memory utilization and heap sizes are an after thought and are not recognized until the application is in production, often caused by application uptime, production request volume or production sets of data. When the OutOfMemory Error occurs, often the science of development seems to brake down and knobs are turned. First the (-mx) maximum heap space gets adjusted... More is better right. The next OutOfMemory, heads start scratching, code reviews start in earnest, and Google gets several new hits. Did you know that it is possible to get an OutOfMemory error without running out of heap space?
Brian Sletten - Forward Leaning Software Engineer
Ok, I can't promise you profit, but hopefully you'll have fun. Maven 2 introduces a number of new features (including that performance feature) that make it a swell project management tool for development.
Come hear about how we can abuse Maven to manage distributed deployment scenarios before the Modules JSR is done.
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. Now that Spring 2.0 provides support for AspectJ, the time has never been better to learn about these new (but backwards compatible) ways of thinking about building software.
Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.
NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
Come see how this open source / commercial product can change the way you think about building software.
There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.
If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.
Venkat Subramaniam - Founder of Agile Developer, Inc.
Annotation is an interesting feature in Java. However, like any features, there are good uses and bad uses. When should you use Annotation? This presentation will answer that question for you.
Domain Driven Design (DDD) is an approach that places emphasis on the domain model and carrying it into implementation. DDD is mostly repackaging of fundamental OO Design. It brings new emphasis to what we should be already doing, but often find it hard and confusing given the realities and complexities of our real world. In this presentation we will take a close look at what DDD is and how to use it for agile development. We will discuss several design options, and also look at some examples of good modeling and layering.
Rule based programming allows us to develop applications using declarative rules. These can simplify development in applications where such rules based knowledge is used for decision making.
In this presentation we will introduce OSGi and discuss how it can help modularize and version your enterprise Java applications.
What do you get when you mix an agile, object-oriented, dynamic language with a lightweight, flexible, and extensible framework? You get a Groovier Spring. Spring allows you to develop using Groovy as much as Java. Groovy brings some neat concepts to the Java Platform that is hard to realize directly through the Java language. Using these capabilities can lead to elegant and easier Spring development.
Mark Volkmann - Software Consultant and Partner at OCI
Developing applications entirely in Ruby isn't always practical. It may be desirable to utilize existing code written in other languages. Also, implementing some functionality in Ruby may not yield sufficient performance. When these situations arise, Ruby can invoke code written in Java or C.
The easiest way to invoke Java code from Ruby is to use JRuby (http://jruby.codehaus.org/). JRuby is maturing rapidly now that Sun is financing much of its development.
C code can be invoked from Ruby by using wrapper code that is generated using SWIG (http://www.swig.org/) or written manually.