By Matthew McCullough

Maven has been on the Java build tools scene for quite a number of years, but the adoption rate in enterprises is now going through the roof. Maven can seem daunting, but this presentation will equip existing Maven users with more efficient techniques and tools to overcome the biggest perceived Maven hurdles and build issues with ease.

We'll examine tools to help you find artifacts in central repositories, manage your corporation's internal Maven artifacts with a proxy tool such as Nexus, view and override dependency graphs, dependency management and multi-module best practices, create OS specific profiles, and leverage the latest Maven plugins for the top Java IDEs.

Topping it off, we will review migration paths from Ant, and why Maven just makes sense with your company's use of the ever growing web of open source libraries. This presentation will take beginning and mid-level Maven users up to a higher level of efficiency and mastery.

Prerequisite: Basic Maven knowledge

By Matthew McCullough

Watch Preview Video

This session will survey a wide range of tools across the Java space. We'll look at utilities such as VisualVM, jstatd, jps, jhat, jmap, Eclipse Memory Analyzer, jtracert, btrace and more.

Open Source is not just a suite of libraries you consume within your application, but now reaches into the space of tools to help you troubleshoot and improve your applications. The price of these tools eliminates barriers to their use and their open source nature allows you to mix and match them into compositions that work well for your application's unique debugging needs.

These tools will help you peel away layers of your application to expose bugs and performance ceilings. We'll interactively analyze the heap and garbage collection cycles of both local and remote applications, take snapshots of heap, query the heap for heavy usage, leaks and augment running code without a reboot and without breaking a sweat. After attending, you'll never look at Java debugging the same way again.

By Matthew McCullough

Watch Preview Video

Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.

In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition.

Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.

Prerequisite: Basic understanding of Subversion or similar version control system

By Matthew McCullough

iPhone development is all the rage both in the mobile entertainment, social networking, and productivity application spaces. As a Java developer, prepare yourself to be a participant in aspects of this new breed and platform of development. Hop on board with a quick start to iPhone application coding in Objective-C and integration with some of our favorite Java web service back-ends such as RESTful Grails.

We'll build out a graphical demo application on the iPhone that depends on and responds to data from a Java web service; then we'll deploy it live to the desktop simulator, and finally, a real iPhone. This presentation will make you conversant in iPhone development procedures and able to make smart decisions about your back end Java web services ability to serve data to iPhone native client apps.

By Ted Neward

  Even though the Java 7 JSR has yet to be formed, some interesting things are beginning to emerge from Sun about what Java7 may include when its formal release contents are finally made public.

In this presentation, we'll examine some of the forthcoming details, including some of the JSR-166 "add-ons" like the Fork/Join framework, some of the proposals for extensions to the JVM to support dynamic languages, and the so-called "closures" proposals circulating around.

By Ted Neward

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

By Ted Neward

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

By Ted Neward

For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes.

In this presentation, Java developers will see the basic breakdown of the Collection API designs, the relationship of the interfaces to the implementations, how to create a new Collection implementation, and how the new Collections introduced as part of JSR-166 (the concurrency JSR) and Java6 make their programming lives easier.

By Ted Neward

Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used.

In this presentation, we'll go over some basic functional concepts, then start seeing how they apply in the FJ library, and show how to use FJ and functional ideas on common Java programming tasks. Let the excuse "I can only use Java" finally be consigned to the rubbish bin, once and for all.

By Ted Neward

Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right?

In this presentation, we'll go over what's missing from the Java Collections library, what is provided via other sources (Google and Apache, among others), and what you can provide for yourself, including a brief foray into the world of functional programing, and how it can make your Java code more elegant.

Prerequisite: Busy Java Developer's Guide to Collections

By Nathaniel Schutta

We've all used web applications that had us screaming at their creators - unfortunately sometimes we're the ones being cursed. Believe it or not, there are some simple steps we can take to ensure that our users have a great experience.

We'll talk about the role of testing, easy ways to make a web site perform as well as where Ajax can help give a richer experience.

By Nathaniel Schutta

Ah, that new project smell, it's intoxicating! Full of hope, we trek off in pursuit of technical greatness. In this talk, we'll cover some of the important first steps of a new project including continuous integration, creating a testing culture and establishing low ceremony process.

Ah, that new project smell, it's intoxicating! Full of hope, we trek off in pursuit of technical greatness. In this talk, we'll cover some of the important steps of a new project including continuous integration, creating a testing culture and establishing low ceremony process.

By Nathaniel Schutta

Being on a high performing team is a transcendent experience - unfortunately, many of us find more dysfunction than function. In this talk, we'll take a look at some of the common issues that face teams and discuss some ways of working towards a happy crew.

Being on a high performing team is a transcendent experience - unfortunately, many of us find more dysfunction than function. In this talk, we'll take a look at some of the common issues that face teams and discuss some ways of working towards a happy crew.

By Nathaniel Schutta

Watch Preview Video

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.

By Ken Sipe

Scale... what is scale... how do you applications that are scalable. How do you know if the application scales?

This session will look at server topologies and state management and how it affects scale. We'll detail a number of metrics to know and observe. In addition tools of the trade will be demonstrated such as jmeter.

By Ken Sipe

This session is a quick look at all aspects of being a corporate software architect. Whither you are a developer looking to move into the role of architect, needing to have an understanding of what is expected or already in the role of software architect looking for new and interesting ideas, this session is for you.

This session is designed to be a jam session on all aspects of software architecture and many of the roles of software architect. The following subject areas will be covered:

- Software Development Process

- Project Key Mechanisms: Languages and Frameworks

- Security: Threats, Securing Code Review, Adding Security to you process

- Layers, Partitions and Topologies

- VM Optimizations

- Usability and User Experience

- Optimizing the Web

- Ready for Production: Monitoring

- Integration

- Data Modeling

By Ken Sipe

Thoughts lead to words, words lead to action, actions lead to habits. In this session we'll sharpen the development saw in the process of understanding what makes a hyper-productive programmer. The focus will consist of developer habits and development processes.

As described in the book "7 Habits for Highly Effective People", there are habits which are characteristic of highly effective people. Clearly there are hyper-productive developers which distinguish themselves from the development pack? what is it that makes the difference? What are the habits and practices of highly effective developers?

This session will focus on individual developer habits, as well as team practices and the processes which result in high quality running software.

By Ken Sipe

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?

This talk will walk through the underlying details of memory management in the JVM with a focus on VM flags available to help configure the VM. However we can't configure the VM without a detailed understanding of what is going on inside the VM. We'll focus on tools available for analyzing the memory in a running VM. Two actual client case examples will be presented. We'll discuss the differences between the two cases and why the end configurations were quite different.

By Brian Sletten

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.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old

By Brian Sletten

The human web is reasonably well in hand by now. We are getting pretty good at building systems that people find valuable and entertaining. We have not spent as much time concerned about our software friends. There is a ton a rich content available on the web that is too difficult to extract in automated ways using just XHTML, the meta tag and microformats. This talk will introduce you to some emerging technologies from the Semantic Web camp to enrich your web pages with useful information for both automated extraction and improved browsing experiences.

The Resource Description Framework (RDF) is the metadata substrate of the Semantic Web. It allows you to express fairly arbitrary relationships about people, places, things, content in an open world way. It is trivial to mix and match terms, vocabularies, etc. to have a rich expressive capability not bound by the limitations of the relational data model and XML schemas.

GRDDL is a technology for generating RDF metadata from content on demand. This can include XML documents, XML-RPC requests, XHTML pages, etc. The content could include authorship information, geotagging, creative commons license information, the topic of the document, etc. RDFa allows us to be more explicit about the metadat

Prerequisite: The Semantic Web: The Future Now would be helpful, but not required

By Brian Sletten

The human-friendly Web is about nicely-formatted, accessible content for users to browse. There is an emerging Data Web that relies on technologies from the Semantic Web stack to link increasingly rich connections between various data sources. SPARQL and RDF are the main tools for expressing and using this connectivity. This talk will introduce you to one of the practical and accessible aspects of employing these ideas on the Web and in the Enterprise.

Getting people to come to consensus on common models and schemas is usually the hardest part of any data integration strategies. These technologies help lower the bar on both the technical and social costs of stepping up your integration strategies.

We will explore:

an introduction to RDF and the SPARQL query language

the fantastically successful Linked Data project that connections billions of interrelated content

how to include relational data in the mix

how to include enriched Web pages in the mix

how to build client-friendly applications on top of this information

Prerequisite: The Semantic Web: The Future, Now and Rich Web Pages : Publishing Semantic Content with GRDDL and RDFa would both be helpful but are not required

By Brian Sletten

The goal for web services was always to reduce our burden by increasing the potential for reuse of business functionality. Somehow, we got lost along the way in a morass of confusing, unfulfilling and downright broken technologies.

While we are interested in pursuing REST-based systems for managing information, we need some strategies for tying it all together sensibly. If we abandon WSDL, SOAP and UDDI, what do we replace them with? This talk will walk you through combining resource-oriented strategies with technologies from the Semantic Web to describe, find, and bind to services in dynamic, flexible and extensible ways.

We will start to blur the distinction between data, documents, services and focus on information and how it is connected to what we already know.

This talk will introduce you to strategies for building on individual REST services to produce a well-described, dynamic, discoverable fabric of services that can be used in a variety of scenarios including:

finding data sources

finding transformation services

orchestrating these sources and services in reusable ways

publishing discoverable services

Prerequisite: The Semantic Web: The Future Now, Give it a REST and SPARQL : Querying the Data Web would all be helpful talks to have attended

By Venkat Subramaniam

By Venkat Subramaniam

Domain Specific Languages (DSLs) are languages targeted at a particular problem and domain. They have context and are fluent. They help users of applications at various levels to easily communicate with your application. Developing DSLs, however, are not easy. You could easily get dragged into using parsers and tools with steep learning curve.

In this presentation, we will look at various options to create DSLs on the Java platform. We will focus on external DSLs–these give you the absolute flexibility to chose syntax, but involve the most work as well. We will look at various tools and techniques that can ease this development effort.

By Venkat Subramaniam

Testing is a key ingredient to the success of a project. However, testing becomes awfully hard when your application deals with dependencies and that is often the reality.

In this presentation we will discuss how to approach testing when the code has dependencies. We will discuss tools, techniques, languages, and principles that can help decouple, mock, and help us effectively test your application code.

By Venkat Subramaniam

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.

In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

By Venkat Subramaniam

In this presentation we will take a quick walk though the issues with concurrency and how the solutions provided in Scala and Clojure help address those.

The gaining popularity of multi-core processors has rekindled the

concurrency question: How do you effectively implement multithreaded

applications on the Java platform? The familiar approach in Java is to

create threads and to manage access to shared mutable state using

synchronized locks. This approach to concurrency is fraught with hard work

and uncertainties. Have you marked the appropriate methods synchronized,

did you decorate the relevant fields volatile, did you properly construct

the mutually exclusive regions of code, and is there a potential for

deadlock lurking in the code.

In this talk you'll learn about alternate ways to tackling concurrency on

the JVM. One approach i

By Venkat Subramaniam

Projects often start out simple, but soon become complex and turn into a lose cannon. Organizations are struggling to maintain and evolve software. Poor code quality is a significant part of that problem. Improving the quality of code is critical to success of enterprise projects.

In this presentation we will discuss ways to identify code smell. We will discuss several

code smells and how to clean it up. We will also discuss proactive ways to avoid that smell

in the first place.

By Venkat Subramaniam

Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you.

In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.

By Craig Walls

Watch Preview Video

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.

It's been 8 years since Spring 1.0 was released. In that time it has gone from a modest open-source project to being a de facto standard Java application framework. Now, as Spring enters its 8th year, it continues its attack on Java complexity, packed with many new features such as:

First-class REST support

A new expression language

More options for annotation-driven bean wiring

Bean profiles

Declarative caching abstraction

Enhanced Java-based configuration

A new "c:" namespace

Unified property management

And much more

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for n

By Craig Walls

In this session, we'll explore modular web application development using Spring-DM and OSGi. I'll dispel the myth that OSGi is hard and show you tips and tricks that make Spring-DM and OSGi development easy.

WAR files, the workhorse standard deployment unit for Java web applications, has been looking a little portly for a long time. Most WAR files contain not only servlets and JSPs, but are usually well-endowed with static content (such as CSS, JavaScript, and images), middle and backend support classes, and a WEB-INF/lib directory chock-full of third party libraries. Even simple web applications can carry around several megabytes worth of baggage.

Monolithic WAR files present some practical issues, including:

- Every WAR file carries its own copy of embedded libraries, increasing the footprint of each web application.

- Parallel development of application modules is hindered, as all module

By Craig Walls

Spring 3.0 introduced the Spring Expression Language (SpEL), an extremely powerful yet succinct way to wire non-trivial values into Spring beans. In this presentation, we'll explore SpEL in great detail and see how SpEL opens up a whole new realm of bean wiring possibilities.

Spring's brand of dependency injection is quite awesome. But there are times when simple bean references and static values won't cut it. Sometimes it makes more sense to wire bean properties with values that are evaluated dynamically at runtime.

That's where the Spring Expression Language (SpEL) comes in. SpEL is one of the most interesting of the many new features in Spring 3.0. With SpEL you can succinctly wire in values derived...

...from system properties

...mathematically

...from the values of other bean properties

...from the results of static methods

...from almost anything you can conjure up

Previously, most of these types of wiring could only be accomplished with more XML confi

By Craig Walls

Writing tests is more than just writing JUnit test cases and hoping that they'll pass when your project is built. If you want assurance that your code is sound and provides the desired functionality, then you'll want to test it from every angle and run those tests as frequently as possible.

In this session, we'll look at a few testing tools that you may not be all that familiar with, including:

Infinitest : A continuous testing tool that reports test failures almost as quickly as you can break them.

Mockito : A relatively new tool for mocking objects in tests.

Concordion : A framework for writing FIT-like functional specifications, without the hassles of FIT.

jqUnit and JSTester : A xUnit-like framework for testing JavaScript.

Selenium : A framework for in-container testing of web applications.

If you're ready to elevate your testing prowess to the next level, come see how these tools can help.

By Scott Davis

"XML is like violence: if it doesn't solve your problem, you aren't using enough of it." (Anonymous)

XML is everywhere. Whether you are dealing with local configuration files (web.xml, struts-config.xml) or remote web services (SOAP, REST, RSS, Atom), the modern software developer needs to be able to request, slice, and dice XML with ease. That requires a set of razor-sharp tools that reduce the inherent complexity of the problem, not multiply it. Once you see XML tremble in fear at the awesome power of Groovy, you'll wonder what you ever did without it.

In this talk, we look at various Groovy tools to create, parse, and export XML. To read in XML, we'll explore the XmlSlurper and the XmlParser. To write out XML, we'll use the MarkupBuilder, StreamingMarkupBuilder, and the XmlNodePrinter. We'll go beyond simple Plain Old XML (POX) and demonstrate using namespaces, CDATA blocks, and more.

By Scott Davis

"Any intelligent fool can make things bigger, more complex, and more violent. It takes a touch of genius - and a lot of courage - to move in the opposite direction." (Albert Einstein)

REST and Resource-Oriented Architecture (ROA) are popping up in technical discussions more and more frequently. Here, you'll see practical examples of adding RESTful web services to your Grails application.

In this talk, we look at the native support for REST that Grails offers on the server side. We'll also take advantage of the networking and XML strengths of Groovy to build out a simple but powerful REST client.

By Scott Davis

"Tests don't break things; they dispel the illusion that it works." (Anonymous)

In this era of "Test-First" and "Test-Driven" development, the modern software engineer knows that testing is no longer an optional part of the process. You need to have the best tools at your fingertips: a set of utilities that maximize your results with a minimum of effort. Groovy offers Java developers an optimal set of testing tools.

In this talk, we use EasyB to gather user stories as executable documentation. We look at GroovyTestCases -- a drop-in replacement for JUnit TestCases that expand the pool of helpful assertions. We'll explore mocking and stubbing with Groovy. And we'll finally go public with Groovy's privacy "issues".

By Scott Davis

"The challenge of modernity is to live without illusions and without becoming disillusioned." (Antonio Gramsci)

There are plenty of sarcastic "Web 2.0" checklists out there -- be perpetually in BETA, when in doubt add rounded corners, etc. While we can all laugh at the superficial aspects of the Web 2.0 revolution, there are plenty of serious aspects to it as well. Is your website mash-up friendly or hostile? Do you tell your visitors when things change (via RSS or Atom syndication), or do you expect them to check in daily for updates? Is your website a silo or a part of a larger ecosystem?

In this talk, we discuss what makes a "modern shiny Web 2.0" website look the way it does. But we go beyond simple look and feel as we catalog the common features in modern websites and show you how to implement them yourself.

By Scott Davis

"There's an old story about the person who wished his computer were as easy to use as his telephone. That wish has come true, since I no longer know how to use my telephone." (Bjarne Stroustrup)

The "lizard brain" is the oldest part of the human brain -- the part responsible for autonomic functions like breathing, heart rate, and navigating websites. OK, maybe not that last part, but your website should be easy to use. Stupid easy. Lizard brain easy. Any time your user spends figuring out how to do something -- even for a split second -- is wasted time due to poor design. Inspired by Steve Krug's book "Don't Make Me Think", this talk answers the question, "Why is that website so hard to use?"

In this talk, we look at what make a "good" website "good". Simple changes in the layout or sort order can yield drastic improvements. We'll get inside the heads of typical users and see how their view of our website is drastically different than what we painstakingly planned out. You'll learn how to cater to "Browsers" and "Searchers" -- the human kind, not the software kind. "Lizard Brain Web Design" answers these questions and more in a funny and informative way.

By David Geary

This session introduces JSF 2.0 fundamentals, with emphasis on new features in JSF 2.0.

JSF 2.0 has been a long time coming, but now that it's here, it boasts an impressive set of improvements over JSF 1.X, including standardization of Facelets as the default display technology, a much richer event model, and built-in support for Ajax. Come to this session to see how you can use Java's standard web application framework to create industrial-strength web applications.

This session will cover the following features of JSF 2.0:

Resources

Using Groovy

System events

Bookmarkable views

Templating

Prerequisite: Familiarity with JSF, or other component-based frameworks

By David Geary

This session covers two of the most important features of JSF 2.0: composite components and built-in Ajax.

JSF is a component-base framework. Components are a powerful reuse mechanism, but they were rendered nearly inconsequential in JSF 1.X, because components were so difficult to implement.

JSF 2.0 makes implementing cusomt components easy with a new feature that builds on Facelets and the new resource capabilities in JSF 2.0: composite components. This session shows you how to implement your own components with JSF 2.

Additionally, this session covers the built-in Ajax that comes with JSF 2.0. Come to this session to see how you can easily implement custom components with integrated Ajax capabilities.

Prerequisite: Familiarity with JSF, or other component-based frameworks. Familiarity with Ajax. This session builds on the JSF 2.0 Introduction talk, so it is helpful, although not required, if you attend the intro talk before coming to this session.

By David Geary

An introduction to Flex for Java developers.

Want to develop expressive web applications? Them come to this session and see what Adobe's Flex is all about. Flex has lots of similarities to Java-based web development, so you'll find it easy to learn, and powerful to use. Come to this session if you want to take your web application user interface to the next level.

This session will cover:

An introduction to Flex

ActionScript, HTTPService, and data binding

Drag and drop

Components

View state

Integrating with Java back ends

Prerequisite: Familiarity with Flex and at least one other web application framework

By David Geary

Learn to implement web applications with GWT.

Google Web Toolkit lets you create killer Java-based web applications using familiar Swing and AWT idioms. This session will introduce you to GWT and teach you the fundamentals of using this cutting-edge framework for creating rich user interfaces that run in a browser.

For most of this session, and the session that follows--GWT fu, Part 2--I will live code a desktop-like, ajax-based, web application that illustrates the awesome power of GWT. In this session, I will cover the following topics:

Widgets

Remote procedure calls and database access

Event handling

Ajax testing

Prerequisite: Familiarity with a component-based framework, preferably a desktop application framework

By David Geary

Learn to do amazing stuff with GWT.

This session picks up where GWT fu, Part 1 left off. In this session, I will continue live-coding the Places application. In taking the Places application to its exciting conclusion, I will cover the following advanced aspects of GWT:

Dialog boxes

Sinking events

DOM elements

Working with HTML

Modules

Image loading and busy cursors

Event previews

Timers

In this session, I focus primarily on implementing a viewport widget in a custom module, and using that widget in the Places application. When I'm done, we'll have a very cool web application that shows the awesome potential of Google Web Toolkit

Prerequisite: GWT fu, Part 1 is not a prerequisite for this session, but it will help if you have some familiarity with GWT.

By Stuart Halloway

If an iteration is the heartbeat of an agile development process, then Iteration Zero (IZero) creates the heart. While you can (and should) retrospect and adjust throughout the software lifecycle, few things are as valuable as a good start. In this talk, you will learn how we run Iteration Zero at Relevance.

The purpose of IZero is to prepare all stakeholders, so that Iteration One can begin normal iteration pace, heading in the right direction. In this talk, we will visit each of the four principles of the Agile Manifesto, and show how to establish them in IZero.

AM #1. Individuals and interactions over processes and tools. In IZero, you should identify the team roles, and find the right people to fill them. You should create places and times (both physical and virtual) to maximize contact and interaction.

AM #2. Working software over comprehensive documentation. In IZero, you establish the practices you will use to create working software, which may include test-driven development, pair prog

By Stuart Halloway

Teams adopting agile should begin at a tactical level, but they shouldn't end there. The Agile Manifesto operates at many different levels. Learn to apply the principles of agile at a strategic level. Otherwise you can have a great agile ground game and still lose.

Many programming teams now embrace agile at the tactical level, which is the right place to begin. Applying the ideas in the Agile Manifesto, good teams embrace practices like

story point estimation

burndown tracking

technical expertise

behavior-driven development

daily standups

pair programming

continuous integration

spiking

refactoring

customer always available

well-understood roles

The Agile Manifesto can be applied at a strategic level, too. However, the tensions are different. Feedback cycles are longer, objectives and results are less clear, and roles and relationships are unknown or changing. In this talk you will learn how

By Stuart Halloway

Agile teams manage change and risk by apapting. But to adapt, you must identify opportunities for change and take them. Retrospectives are a fun, cost-effective way for your team to learn and change.

In this talk, we will begin by conducting a mini-retrospective, so that you get a feel for the basic process. Next, we will review the core principles of a retrospective, and use these principles to compare and contrast a variety of retrospective activities from the book Agile Retrospectives.

Next, we will explore a few retrospective activities in greater detail. These are some of the favorites that we use regularly at Relevance:

team radar

prioritize with dots

learning matrix

Finally, we will talk about how to tune retrospectives to the needs of your team at a specific moment in time. No two retrospectives are alike, and an experienced facilitator adds value by adapting a retrospective

By Stuart Halloway

In this talk, we will explore and compare four of the most interesting JVM languages: Clojure, Groovy, JRuby, and Scala. Each of these languages aims to greatly simplify writing code for the JVM, and all of them succeed in this mission. However, these languages have very different design goals. We will explore these differences, and help you decide when and where these languages might fit into your development toolkit. For more information see http://blog.thinkrelevance.com/2008/9/24/java-next-overview.

As we reach the middle of our second decade of Java experience, the community has learned a lot about software development. Many of our best ideas on how to use a Java Virtual Machine (JVM) are now being baked into more advanced languages for the JVM. These languages tend to provide two significant advantages:

They reduce the amount of ceremony in your code, allowing you to focus on the essence of the problem you are solving

They enable some degree of functional programming style. Think of it as a dash of verb-oriented programming to spice up your noun-oriented programming.

In this talk, we will explore and compare three of the most interesting new JVM languages: Clojure, Groovy, JRuby, an

By Stuart Halloway

Find out why Clojure is Java.next:

• Clojure provides clean, fast access to all Java libraries.
• Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python.
• Clojure includes Lisp's signature feature: Treating code as data through macros.
• Clojure's emphasis on immutability and support for software transactional memory make it a viable option for taking advantage of massively parallel hardware.

Clojure is a dynamic programming language for the Java Virtual Machine, with a compelling combination of features:

Clojure is elegant. Clojure?s clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.

Clojure is Lisp reloaded. Clojure has the power inherent in Lisp,

but is not constrained by the history of Lisp.

Clojure is a functional language. Data structures are immutable, and most functions are side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.

Clojure simpli?es concurrent programming. Of course, Java itself has pretty good concurrency support. Bu

By David Hussman

Many people simplistically apply agile recipes, assuming a one size fits all approach. This may lead to naive use beliefs like collocation breeds instant success. While sitting together always helps, it does not mean that people spontaneously collaborate to create sustainable value.

Instead of approaching agile methods like a recipe, this session will teach you to design agility that is a useful tool for your project community. We will cover practice selection ideas, tools for creating healthy development eco-systems and product discover tools. If you would like to improve the stickiness of your agility, stop in learn a pile of techniques to use before holding your first planning session.

Imagine you want to use agile methods and you’re looking for ideas from introduction to iteration, this is the path we will take. We start by will examining ideas for selecting which practices will improve your existing strengths and address your existing issues. From there, we will walk through growing product and customer knowledge, creating a collaborative work area and two levels of planning: planning to discover and planning to deliver.

By David Hussman

This session speaks to the question being asked so often: "what is an agile coach" From guiding planning sessions to pairing with developers to helping teams groom backlogs, this session provides insight into coaching agile projects and fostering the agility that produces. Whether you are a manager, developer, or tester, if you are interested in leading the adoption or tuning agility, this session will help prepare you for your first coaching gig.

The session starts by questioning how you might coach, after which we will walk through a project from a coach's perspective. From preproduction (getting ready to produce) to finding your groove (getting productive) during the early iterations. The session closes out with a few ideas for staying productive and keeping the band together. Show up ready to learn about and experience a slice of agile coaching.

By David Hussman

While actors and use cases often left users behind, personas and story maps bring the users to life and help mine real value. This session will teach you how to craft personas and use them to drive value into your development stream. The tools presented will help you better understand your buyers and users and build strong product backlogs and product road maps.

The session starts with an overview of what personas are and why people use them. From there, we will start from the beginning: who do you use to pattern your personas and who has the best skills to create them. Once we have created a few personas, we will explore how they can be used to craft story maps, create acceptance tests and help keep the user's experience, and their needs in the minds of the development community.

By David Hussman

People ask me all the time, "How do you get people to buy in the use of agile methods?" While this is easier than it once was, there are still many challenges, and agile snake oil sales are on the rise. If you are looking to sell agility or deeper your agile investment (or your sales force), this session will provide you with tools that will help you frame your sell points, select your sales tools and communicate the value (of a practice) over the mechanics.

This session will start out showing how agility sells (or does not) and where the sales have added value or simply added noise. From there, we will talk about the value of various practices as we re-frame them into valuable items which sell. Lastly, we will finish up talking about how to sell each of these to the various buyers within organizations: managers, directors, tech leads, developers, business partners and more.

By Brian Sam-Bodden

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Some of the topics covered include:

- Handling and implementing inheritance

- Caching

- Profiling your queries

- Using filters for virtualization

- Custom SQL for performance

- Query caching

- ... and more

By Brian Sam-Bodden

Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

Software development is expensive, when business rules are hard-coded in your application's source code, changes and additions to those rules translate to wasted time and money. Good object-oriented, component-based approaches can alleviate the burden of keeping up with changes in the business world but they still require that expert knowledge of the changes be passed from the decision makers to the business analysts and finally to programmers that need to implement these changes. Business Rule Engines and Business Rule Languages are based on the basic premise of separation of concerns by empowering business domain experts to express the rules of business in a way that it is directly usable

By Brian Sam-Bodden

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules application covering such topics as:

• Fine control and monitoring of a Working Memory session
• Using Decision Tables
• Advanced Rule Language Features
• Building Domain Specific Languages
• Managing your Rules

Many of the problems that we deal with in enterprises around the world are not usually related to the particular infrastructure, framework or programming language chosen but rather to the evolution and maintenance of the business logic that governs those systems. All knowledge in an enterprise is handed down stream until it arrives at the programmer's door. With Rule based systems we can empower those with the business but there is still a fair amount of work to get the ideal architecture for a particular problem in place.

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules ap

Prerequisite: Beginning Drools

By Brian Sam-Bodden

In this session we will explore the Java tools, techniques and algorithms that enable us to filter, classify, relate and discover patterns in our data that might not immediately obvious. With the emergence of social networking applications a great deal of data and hidden connections that can be leveraged to build better and smarter applications.

In this session we will explore the Java tools, techniques and algorithms that enable us to filter, classify, relate and discover patterns in our data that might not immediately obvious. With the emergence of social networking applications a great deal of data and hidden connections that can be leveraged to build better and smarter applications.

The session will explore:

- Data Mining

- Text Classification

- Semantic Searching

- Weka