Session Schedule

By Ryan Breidenbach

In 2006, Spring 2.0 was released and Spring became ubiquitous in the enterprise Java space. So if you haven't taken a peek at Spring yet, what are you waiting for?!? If the answer is "This session," you have come to the right place. This session will familiarize you with the benefits Spring provides and why they have made the framework so successful. In addition, we will focus on the efforts that went into Spring 2.0 to make these benefits much more developer friendly. By the end of this session, you should have a grasp of how Spring 2.0 simplifies the utilization of Spring's core features such as bean wiring, AOP, and the simplification of using enterprise Java. If your head is not spinning too much.

In this session we will cover: - Brief history of Spring - Overview of Spring's core values and features - New Spring 2.0 features - Glimpse of upcoming Spring 2.1 features

By Ryan Breidenbach

Although Spring's rise to ubiquity was driven by its IoC and AOP services, it offers so much more. One of the most powerful of these services is Spring's MVC framework.

If you are familiar with other Java web frameworks such as Struts or WebWork, you will recognize that Spring MVC is a similar request-response web framework driven by a Front Controller, in this case the DispatcherServlet. But Spring also provides considerable functionality out of the box. One of the beauties of the Spring MVC is that, like the rest of Spring, all of its components are quite modular. This allows you to mix and match different implementations of the various MVC components as you see fit for you application.

In addition, Spring MVC provides rich capabilities for data binding. This allows you to transparently bind form parameters to your application objects without having to create any intermediate objects. Spring's validation features allow you to capture both binding and application errors. And with Spring 2.0's much improved JSP tag library, both creating forms and displaying validation errors is quite simple.

In this session we will cover: - A quick overview of Spring for first time Spring users - Configuring Spring's DispatcherServlet - Wiring other application beans to web application beans - Mapping requests to Spring Controllers - Spring's different Controller implementations, and when they should be used - Validation form parameters and binding them to application objects - Creating forms using Spring's custom JSP tags library

By Ryan Breidenbach

2006 appeared to be the year that Maven achieved the momentum it needed to overtake Ant as the build tool of choice for Java developers. A lot of that has to do with the vastly improved Maven 2. But it lot of it has to do with the simplicity, organization and power that Maven brings to projects. The session will bring developers new to Maven with everything it has to offer. This includes creating your very first Maven project, learning the significance of the POM file, how to let Maven and its repositories manage your dependencies, and how to let Maven report of the health of your own projects. And for the Ant users in the audience, you will get to see a side-by-side comparison of the two build tools' build philosophies.

In this session we will cover: - Fundamental differences between Ant and Maven - Maven fundamentals: the POM file and Maven repositories - Dependency management - Creating a build artifact using Maven - Filtering application resources - Migrating from Ant to Maven

By Jeff Brown

Groovy is an agile dynamic language for the Java platform. Groovy has a Java like syntax along with many features inspired by languages like Python, Ruby and Smalltalk. This session covers a lot of ground including many interactive examples to hilite the powerful language features that make Groovy compelling. A lot of momentum is building in the Groovy and Grails communities right now and this session is aimed at Java developers who want to leverage the power of Groovy.

This session is targeted to demonstrate the power of Groovy and help Java developers understand how to leverage that power in their enterprise applications. Topics include: Everything Is An Object GStrings Closures Collections Groovy Builders Groovy Beans Categories Ranges Java Integration

By Jeff Brown

The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.

This session will cover using Groovy to test Groovy and Java code, web applications and desktop applications. The session will include a lot of live code examples demonstrating the power of Groovy in testing.

By Jeff Brown

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.

This session will demonstrate how easy it is to get a simple application up and running with almost no effort and then evolve that application by adding features to really show off the power of the Grails framework. Topics include: Grails Quick Start The Grails Command Line Tools GORM and Hibernate Groovy Server Pages (GSP) Spring Integration Unit Testing Functional Testing

By Jeff Brown

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.

This session will cover all of these topics to demonstrate how powerful the Grails framework is and show how little effort it takes to build not just a simple toy application but also to build real enterprise web apps.

By Scott Davis

This is the year of the dynamic scripting language. Ruby (and Rails) has won the hearts and minds of many independent software developers. JavaScript is experiencing a renaissance thanks to the wild success of AJAX and websites like Google Maps. And Groovy (JSR-241) brings the same level of excitement and "scripting goodness" to the Java platform.

In this presentation, we take a very pragmatic "prove it in code" approach to learning Groovy. Since the syntax is (almost) identical to Java, we can dive right in from the very beginning, learning the "syntactic sugar" as we solve real world problems. You'll learn how easy it is to install Groovy and get started working with it. You'll tackle file I/O, reading and creating text files. You'll create and parse XML and HTML. You'll interact with databases. You'll create Groovlets (servlets sprinkled with Groovy-dust). And finally, you'll get a brief introduction to Grails (hint: the 'G' is silent).

By Scott Davis

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.

We'll look at calling Groovy from Java. We'll look at calling Java from Groovy. We'll look at compiling Groovy code, JARring it up, and deploying it alongside Java. Groovy offers the same level of integration with Ant. We'll look at Ant tasks that allow you to include Groovy in your build process. Or maybe you'd prefer to use the Groovy AntBuilder and completely manage your build in code. The choice is yours. The important thing is Groovy works along side your familiar toolkit instead of forcing you to replace it.

By Scott Davis

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.

Grails is a fully integrated, modern Java web development stack. In a single zip file, it includes a web server (Jetty), a database (HSQLDB), a build system (GANT, a Groovy/Ant hybrid), a logging framework (Log4J), and a unit testing framework (JUnit). It also includes mainstream libraries like Spring for dependency injection, Hibernate for Object/Relational mapping, Quartz for scheduling, and SiteMesh for page layout. For Ajax, Grails allows you to choose between three major included technology stacks: Prototype/script.aculo.us, the Yahoo UI library, and Dojo. Coupling the power of these mainstream libraries with the ease-of-use that Groovy offers, you have an unprecedented collection of te

By Scott Davis

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.

REST isn't a specification or a framework -- it's a set of architectural principles. This means that you can begin using it immediately. No framework wars, no version mismatches. This talk demonstrates some of the more popular RESTful web services out there in the wild. It also shows you live examples of how to implement your own. We'll look at the simplest form of REST -- GETful web services. We'll also look at more sophisticated RESTful interfaces that utilize all of the HTTP verbs (GET, POST, PUT, and DELETE) and MIME types. Finally, we'll look at Atom and the Atom Publishing Protocol -- the RESTful implementation that Google chose to replace its aging SOAP implementation.

By Scott Davis

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.

As more software engineers add unit testing to their everyday development regime, the concept of mock objects is becoming increasingly popular. Mock objects proxy more complicated objects, fulfilling their doppelganger's interface and behavior for testing purposes. Coding to interfaces instead of implementations is a best practice that applies equally well to POJOs and Web Services. Web Services, too, are being added to our toolkit with increasing frequency. Building a true service-oriented architecture brings with it new challenges: how do you code against an external service? If that service is metered, how do you develop iteratively without using up your production budget in tests? Thes

By Neal Ford

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.

It is too easy to get into a coding slump and not realize it. This talk revitalizes your relationship to code, forcing you to rethink some of the thing that you take for granted and showing new approaches to solving hard problems. It covers topics that range from improve the overall structure of your code to the way you write JavaBeans, with lots of examples. Everything in this talk may not be new to you, but I guarantee that you'll see some things that will make you reevaluate the way you think about your code. Session Outline: TDDStatic AnalysisGood Citizenshipgetters and setters ConstructorsStatic StateYAGNIOccam and His RazorQuestion AuthorityDSLsJavaBean Specification SLAPNew Langua

By Neal Ford

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.

No subject has been subject to more recent hype than Service-Oriented Architecture (I think it was because of a really good article in an in-flight magazine). For whatever the reason, the CxO has decided that we need one. It's up to you to implement it. This session is all about the technical considerations required to implement a service oriented architecture. It discusses technology choices, what is in (and out) of SOA's scope, how to implement transformations, routing, and other key services, how to version endpoints, and finally testing and debugging SOA. This session is marketecture free: it covers the details you need to implement this style of architecture. Session Topics:What SOA me

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.

This session shows how to fully exploit regular expressions. It begins with the basic premise of how regular expressions work, then shows how to take advantage of the RegEx library built into the Java platform. This session shows how to use wildcards, escape characters, meta-tags, character class operators, look-aheads/look-behinds, and how to use the greedy operators effectively. It covers regular expressions from the beginning through to advanced usage, both in Java and in tools that support regular expressions. This session is packed with real examples of regular expressions (including a game show with no fabulous prizes). Key Session Points: Regular expressions defined Examples Using t

By Neal Ford

About bridges, languages, engineering, polyglot programming, and the near future.

Other engineers sneer at us when we call ourselves "Software Engineers", and they have a point. This keynote discusses real comparisons between traditional engineering and the software kind. It also delves into what it will take to make our profession a real engineering discipline and the near future of languages and environments. Come see your future.

By Neal Ford

What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.

Agile projects focus on delivering code. The responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools (both byte and source code), useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks. Session Topics:The Hawthorne EffectHow Agility and Metrics Feed Eac

By Neal Ford

This session discusses building Domain Specific Languages and DSL-style code in Java, Groovy, and Ruby. It discusses the different types of DSLs, details on how to implement them in Java, Groovy, and Ruby, and example problem domains where DSLs make sense.

You've heard all the hype for the past couple of years: Domain Specific Languages (DSLs) are going to take over the world. This session demystifies this topic in 2 ways: by providing concrete definitions for styles and applicability of DSLs and showing how to implement these different styles. I build up definitions for the different types of DSLs in static (Java) and dynamic (Groovy and Ruby) languages. Then, I discuss building DSLs as internal (i.e., built on top of an underlying language) and external (built using a preprocessor or grammar), with examples of each. Throughout this session, I discuss the applicability of this style of development and show targeted examples. I discuss fluent

By Neal Ford

This session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.

Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This session describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This session also demonstrates some areas where it makes sense to mixin Ruby and Java code: Rails on Java, testing, and dynamic programming. JRuby is a powerful implementation of Polyglot Programming, and this session shows you how to leverage this cutting-edge concept. Session Topics:JRuby's originsCalling Java from RubyCalling Ruby from JavaLimitations and pitfallsExample usageRails on JavaTestingDynamic programmingThe

By Neal Ford

This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment...on the JVM, using JRuby.

Find out why everyone won't shut up already about Ruby on Rails! This web framework for Ruby has appeared from nowhere to become the critics darling: there must be good reasons why. This session shows those reasons, in a context familiar to Java developers. It discusses how configuration works in Rails, persistence through ActiveRecord, scaffolding, controllers, views, and Ajax. It also covers the important topic of testing, and how Rails makes it easy and automatic. Finally, this session discusses deployment on the JVM, using JRuby, and reflects back on the important lessons that Rails teaches Java developers. This session also presents information about the boundary between Rails, Ruby, a

By Neal Ford

As out applications have spilled from the server across the wire to the web tier, we increasingly must debug and test in the browser. This session covers debugging and testing tools for clients, JavaScript, and Ajax.

As the browser has become important again, our applications have spilled out of the server side to the web tier, and now we have to debug and test there. This session is all about debugging and testing the web tier. I discuss the tools Firebug, Venkman, the Developer's toolbar, and bookmarklets for debugging JavaScript, Ajax, and general browser behavior. Then, I discuss testing the web tier, first with unit testing via JsUnit, the user acceptance testing with Selenium and Sahi. This session is packed with examples and demonstrations, including real-world scenarios and pitfalls. Session Topics:DebuggingFirebugVenkmanDeveloper's ToolbarBookmarkletsTestingJsUnitSeleniumSahi

By Neal Ford

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.

By now, just about everyone has heard of Selenium, the revolutionary open source testing tool for web applications. This session takes Selenium to the next level, showing how to handle complex, real world scenarios in Selenium. It discusses Selenium setup for both TestRunner and Remote Control. Mostly, though, this session delves into specific techniques for testing real world kinds of behaviors in web applications. I discuss data driven tests, generated tests, decision points in tests, interactive Remote Control, integration with continuous integration, testing Ajax applications (including applications that only Selenium can test), and future directions. This session will turn up the volume

By Neal Ford

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.

In The Productive Programmer, David Bock and I identify 5 principles of productivity: this talk goes into great detail on 3 of those principles. The session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers keyboard shortcuts (including ways to make better use of them) in both IntelliJ and Eclipse. Focus describes how you can modify both the operating system and your code base to eliminate noise. Indirection shows how a simple concept can have profound effects, including how to share a common set of plugins across an entire Eclipse

By Neal Ford

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.

In The Productive Programmer, David Bock and I identify 5 principles of productivity: this talk goes into great detail on 2 of those principles. The session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Canonicality (the DRY principle from The Pragmatic Programmer) discourages repeating artifacts in projects. This talk shows effective ways to avoid this repetition. For example, I show how to reuse documentation via a Subversion hook that posts comments to a Wiki with an RSS feed. Automation refers to making the computer do more work for you. This t

By David Geary

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.

This session is taught by a member of the JSF Expert Group for JSF 1.0 and 2.0., and co-author of the best-selling book on JSF: Core JavaServer Faces. David will take you through a whirlwind introduction to JSF including what JSF is, how it was developed, and how you can best take advantage of the technology. Here is a list of topics: Components, managed beans, value expressions, and static navigation i18n, CSS, and actions The Faces Context and Faces messages The JSF Event Model Using JavaScript with JSF This introduction to JSF also contains 5 live-code demos, where David will develop a simple, but robust application during the course of the session.

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.

By David Geary

An introduction to the popular Prototype JavaScript framework, and two frameworks built on top of Prototype: Scriptaculous and Rico.

Web2.0 is all about rich, interactive user interfaces (UIs), and these three frameworks provide the capabilities that you need to develop those UIs. Prototype (prototype.conio.net) is a low-level JavaScript framework that adds significant features to JavaScript that make it easier for you to use the language and to incorporate Ajax calls in your applications. Scriptaculous is a framework (script.aculo.us) built on top of Prototype that adds some pizazz to Prototype with features such as a wide array of special effects, animation, and drag and drop. Rico is another framework (openrico.org) built on top of Prototype that, among other things, provides something known as behaviours, where yo

By David Geary

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.

JavaServer Faces, with a mature component model and flexible lifecyle, is a perfect platform for implementing Web 2.0 user interfaces with Ajax. This session explores using JSF and Ajax to create applications that act like desktop applications but run in a browser. We'll start with a quick look at implementing basic Ajax in a JSF application. Then, once your bloodthirst has been slaked, we'll dive deeper into Ajaxian Faces dynamics with a form completion demo that requires its implementor to understand two simple, but vital facts about JSF. If you're savvy, you probably use client-side validation to augment your server side validation logic, which parenthetically, is no no-brainer in eithe

By David Geary

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.

JSF has been out for nearly three years now, and in many respects, the JSF specification has become a bit long in the tooth. Fortunately, the open source community has picked up the ball in a big way. In this 2-session presentation, we will explore three open source projects based on JSF--Seam, Facelets, and Ajax4jsf-- that will propel you into the stratosphere of productivity. Seam is a framework from JBoss that combines the JSF and EJB3.0/Hibernate 3.0 frameworks into one component model. That means you only have to learn one framework to build compelling web applications. This is the first of a two-part session, where we'll focus mostly on the Seam framework.

By David Geary

A continuation of a 2-session presentation on Seam, Facelets, and Ajax4jsf.

In the second part of this 2-session presentation, we'll turn our attention to Facelets and how you can use this compelling display technology with Seam. We will also discuss Ajax4jsf and demonstrate how you can use that framework to create rich, interactive user interfaces for your JSF-based web applications.

By David Geary

Developing highly interactive web applications, for the most part requires knowledge of a wide array of technologies: HTML, CSS, JavaScript, XMLHttpRequest, JSP, JSF, etc.

With the Google Web Toolkit (GWT), Google turns that notion of development on its head. Instead, you implement Ajax applications by writing almost entirely in Java. You use an AWT-like API, which the Google compiler compiles to JavaScript that runs on the client.

In the early days of Java, application development with the AWT was relatively simple. You had to have a decent understanding of Java and AWT fundamentals, but once equipped with such knowledge, you could dive in and develop some impressive applications. Ten years later, we have, in so many respects, gone significantly backwards. We've shoehorned technologies such as HTML into shoes for which they were never intended, and for our efforts, we have a mismatch of disparate technologies that one needs to knit together for a truly interactive web application. This is the first session of a two-part presentation on the GWT, where I'll concentrate on GWT basics: implementing Ajax-enabled applicat

By David Geary

The second part of a 2-session presentation on the Google Web Toolkit.

In this session, we'll dive deeper into the GWT and explore some of it's more advanced aspects, such as implementing custom widgets, deploying your application in a servlet container, and implementing drag and drop.

By Jared Richardson

Agile practices are popular because they work, but getting people to take that first step can be tricky.

We'll look at how continuous integration was successfully introduced to a very large, established software shop and used to introduce other Agile practices. Let's see what lessons we can draw from this example that you can take back to your shop.

By Jared Richardson

How do you keep a team scattered across time zones in sync?

It's difficult to keep a local team coordinated. When we add geographical distance to the equation, problems are immediately magnified. We'll talk about techniques that you can use to be sure everyone is sharing information and on the same page whether they're in the same office or in different time zones.

By Jared Richardson

An overview of the Agile software approach from the book Ship It! A Practical Guide to Successful Software Projects.

This book provides a comprehensive look at the software life cycle and can be used to retool the way you, and your team, builds software. While we can't cover the entire book in nintey minutes, we can look how a holistic view of the software life cycle helps you improve your projects and makes your life easier.

By Jared Richardson

Continuous Integration is increasingly recognized as a vital practice in an Agile software shop. Traditionally it's been difficult to set up and administer. Today, that's no longer the case.

We'll look at Cruise Control, a popular CI package. We'll start with the "quick-start" binary release, then change the set up to point to our own project. When we're done, you'll be able to set up your own Cruise Control install on Monday morning.

By Jared Richardson

Throughout our software careers we learn habits from our coworkers, from books we've read, and occasionally, from conferences we attend. Much of our competence comes from the tips and tricks we pick up as we go.

In this session, learn five of the techniques I've borrowed along the way. We'll discuss The List, code reviews, code change notifications, daily meetings, and tech leads. These techniques are often abused, but when used properly they can make a huge difference in how you develop software. Take this opportunity to add these practices to your toolkit.

By Jared Richardson

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.

We'll examine these strategies and then look at scenarios for using them next week. This presentation will get you started whether you're starting a new project or trying to clean up an existing one.

By Jared Richardson

A great team builds great software, but how do you build a great team?

Let's move beyond getting lucky and look at some key practices that will help you build your scattered cats into a well-oiled machine.

By Brian Sam-Bodden

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project. In this session you will learn: - Understanding the O/R Impedance Mismatch - Techniques of O/R Mapping - Persistence Frameworks

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

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application.

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application. In this session learn the foundations of building Eclipse RCP applications, including SWT and JFace and we will use the concepts learned to create a professional looking Java application that can rival any .Net application.

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

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.

NetKernel makes the things you are doing now easier, but also makes new types of systems possible. A wise man once said, "XML is like lye. It is very useful, but humans shouldn't touch it." If you've had to incorporate XML into your project by hand, you have probably been burned by getting too close. NetKernel turns this wisdom on its head and encourages you to use XML like the liquid data stream you want it to be. But, XML is only part of the story. Resource-oriented computing is a generalized and revolutionary approach to modern, flexible systems. There is less code to write, but it is more fun to do. Orchestration of existing services and data sources is faster, easier and more encompas

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. 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.

Attendees will learn about The history and reasons behind AOP Development-oriented aspects that can be useful, but compiled out of production code Production-oriented aspects that can simplify development and ease the burden of future changes Basic AspectJ usage and jargon How to use AspectJ with Spring Rating: Intermediate Category: Architecture/Languages, Client Side Java, Server Side Java Prerequisites: Basic Java. Some level of AOP understanding is helpful, but not required. The pace of the introduction will depend on the average level of exposure the audience has previously had to AOP.

By Brian Sletten

Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al inform us that what we have seen so far is just the beginning. His original plans at CERN were larger and grander. The Semantic Web is the new vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. While there are many naysayers chiding such grand visions, there are also pragmatic and useful technologies emerging that can be applied today.

Attendees will learn: The history and motivations behind the Semantic Web The technology stack that will make it happen (including RDF and OWL) An overview of tools and technologies that are beginning to satisfy the vision This talk stands on its own, but feeds into the "Experiencing the Semantic Web" talk which is more hands on. Rating: Intermediate Prerequisites: This is all so new, most engineers will find something to excite them.

By Venkat Subramaniam

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.

In this presentation we will take a closer look at annotation. We will see how to write them, how to use them. Then we will take a look at examples of annotation in various Java applications/frameworks. We will discuss examples of good use and not so good use. We will then lay out some good practices to follow.

By Venkat Subramaniam

What benefit do new Java 6 features offer you. Are there issues with using these features. The objective of this presentation is not simply to introduce you to the features, but to the effective use of these as well.

We will take a close look at a number of features that you will be expected to know well when you program using Java 6.

By Venkat Subramaniam

In this presentation we will introduce OSGi and discuss how it can help modularize and version your enterprise Java applications.

In this session we will delve into: What is OSGi? OSGi fundamentals Modularization and versioning Developing and deploying components OSGi implementations OSGi and Spring integration

By Venkat Subramaniam

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 take a look at Drools and its evolution into JBoss Rules and how you can express rules including Groovy and other alternatives. We'll taken an example oriented approach to creating a sample application.

By Venkat Subramaniam

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.

Domain Model Model and the implementation Domain objects and life cycle Developing with domain model Design strategies Refactoring

By Venkat Subramaniam

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.

In this presentation we will cover topics including: Strengths of Groovy Using Groovy in Spring Configuration Bean Development Deployment How it fits in

By Venkat Subramaniam

Unit testing tells you, the programmer, that your code (and the change) meets your expectations. How do you know if you are meeting your customers' expectations? Agile development is all about feedback and doing what's relevant to the customers, isn't it? Framework for Integration testing or Fit helps you to automate tests for customer expectations.

In this presentation we will learn how to write Fit tests and how to automate their execution. We will also use FitNesse. Topics: Beyond Unit Testing Integration Testing Customer Expectations Writing Fit Tests Writing Fixtures Automating tests What is FitNesse Using FitNesse

By Venkat Subramaniam

You have worked on software projects with varying degree of success. What were the reasons for the success of your last project? What were the reasons for those that failed? A number of issues contribute to project success - some non-technical in nature. In this presentation the speaker will share with you practices in a number of areas including coding, developer attitude, debugging, and feedback. The discussions are based on the book with the same title as the talk.

In this session you will learn about practices beyond what well know methodologies prescribe. While we reemphasize some popular practices, we will also discuss other often overlooked, but important practices - practices that contribute to success of projects.

By Venkat Subramaniam

You are convinced that Test Driven Development is good for you and your project. You realize the benefits it has to offer. What's holding you back? All the code and components that your code so heavily depends on is most likely making you wonder if TDD is really for you. We will start out by looking at dependency and dependency inversion. Then we will discuss how mock objects can help separate our code from its dependencies.

In this presentation, we will take an examples oriented approach to utilizing mock objects. We will first hand toss a mock and see how our code benefits from it. Then we will take a look at using frameworks that can assist with the creation of mocks.

By Venkat Subramaniam

Most interest around Functional Programming (FP) has been academic until recently. Recent commercial languages are beginning to exploit FP features. Knowing more about FP will not only help us make better use of these features, but to exploit those. In this session we will take a close look at FP.

What is FP? Strength and weakness of FP FP languages for Java programmers Examples that you can use today Thinking in FP