Session Schedule

By Robert Fischer

The power of multicore machines and cloud computing is all dependent on an application's ability to successfully leverage concurrency. Although concurrency has traditionally been considered fatally difficult in Java, a few simple architecture principles can make all the difference. This session will review some of those principles in both theory and practice.

This session will review the theory of concurrency and the different levels that concurrency will act on. With that basis, it explores the theoretical reasons behind the difficulties in writing concurrent code, and then some practical application architecture techniques to cope with those difficulties.

By Robert Fischer

JConch is a library that provides a few high-level tools for high-concurrency environments on the JVM. The java.util.concurrent package in the Java standard library provides low-level structures for managing concurrent communication. Learn here how to use both of them in order to produce clean, highly-concurrent, and highly-tunable code.

Programming in a concurrent fashion is quickly becoming mandatory for applications. This session will explore the best ways to do that on the JVM.

By Robert Fischer

For years, the venerable Hibernate object-relational mapping framework has dominated the persistence scene in Java. The Grails web application framework extended Hibernate and Spring with their impressive GORM persistence framework, providing convention-over-configuration development to the O/RM and DAO layers. This session will introduce GORM and work up to some of its intermediate features.

Before too long, every data access layer starts to look the same. Spring recognized this and provided some common functionality. The Grails web framework went one step further and provided conventional access to their ORM objects. Now GORM is available to non-Grails applications as well, so this session should have universal appeal.

By Robert Fischer

The Grails web application is an innovative hybrid of best-of-breed Java technologies and dynamic/convention-based development. The result is a powerful, flexible, exciting framework that still fits comfortably into enterprise stacks. This session introduces Grails, but approaches it from the perspective of an enterprise web development stack, in order to see how Grails works well in mid-size and mature development shops.

Some technologies seem to think that running on the JVM is all that it takes to be enterprise-ready, but the reality is that there is a large context of standard Java technologies like Spring, Hibernate, Log4J, JNDI, and app servers that make up the backbone of enterprise Java shops. This presentation will show how Grails naturally fits into that context because it is built off of those existing technologies.

By Neal Ford

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

Refactoring is a fine academic exercise in the perfect world, but we don't really live there. Even with the best intentions, projects build up technical debt and crufty bad things. This session covers refactoring in the real world, at both the atomic level (how to refactor towards composed method and the single level of abstraction principle) to larger project strategies for multi-day refactoring efforts. This talk provides practical strategies for real projects to effectively refactor your code.

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

By Neal Ford

Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!

In The Productive Programmer, I identify 4 principles of productivity: acceleration, focus, automation, and canonicality. This 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 ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. Canonicality (the DRY principle from The Pragm

By Neal Ford

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain.

Most of the software world has realized that BDUF (Big Design Up Front) doesn't work well in software. But lots of developers struggle with this notion when it applies to architecture and design. Surely you can't just start coding, right? You need some level of understanding before you can start work. This session describes the current thinking about emergent design & evolutionary architecture, including both proactive (test-driven development) and reactive (refactoring, composed method) approaches to discovering design. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with t

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

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 Scott Leberknight

The Spring framework has simplified Java enterprise and web development since 2003, and has been a major innovator in improving and simplifying Java server-side programming since its inception. This session will look at the new features in Spring 3.0.

Spring 3.0 refactored much of the Spring core so it will no longer run on Java 1.4 and earlier, meaning it is optimized for Java 5 and beyond. Spring 3.0 includes several notable new features like the expression language (EL), support for REST, Spring MVC improvements including @PathParam and URI templates, and much more. In addition, Spring 3.0 will deprecate and remove from the Spring core several APIs like the original Spring MVC controller hierarchy and JUnit 3.8 support. There is also new support to make scheduling jobs cleaner and easier.

Prerequisite: Basic understanding of Spring framework.

By Scott Leberknight

Spring provides a solid foundation for web and enterprise applications. Its support for dynamic languages like Groovy adds interesting capabilities that can make your application architecture more flexible and dynamic.

This presentation will look at how Spring's support for dynamic languages, and Groovy in particular, can enhance your application.

By Scott Leberknight

Hibernate is a very powerful object/relational mapping framework. This session contains a new set of Hibernate tips, tricks, and pitfalls.

In this session we'll look at a collection of tips, tricks, and pitfalls for using Hibernate effectively. Some topics we'll cover include: optimistic locking pitfalls with object versioning; using StatelessSession for bulk operations; extending Hibernate dialects to register native functions; using contextual sessions; pitfalls when using "all-delete-orphan" cascades; "shared" objects using unidirectional mappings; detached objects; and more.

Prerequisite: Basic understanding of Hibernate.

By Scott Leberknight

Polyglot persistence is all about considering your persistence requirements and selecting a persistence mechanism that best mets those requirements, as opposed to selecting an RDBMS as the default choice. In this session we'll look at some of the persistence alternatives that are available like Amazon SimpleDB, CouchDB, Google Bigtable, and more.

In late 2006 Neal Ford wrote about Polyglot Programming and predicted the wave of language choice we are now seeing in the industry to use the right language for the specific job at hand. Instead of assuming a "default" language like Java or C# and then warring over the many different available frameworks, polyglot programming is all about using the right language for the job rather than just the right framework(s). Paralleling Neal's description of polyglot programming, a relational database is often the accepted and default choice for persistence. Sometimes this is due to the fact that organizations have standardized on RDBMS systems and there isn't even any other choice. Other times it is

Prerequisite: None, though a general understanding of data persistence might be useful.

By Matthew McCullough

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.

This session will quickly survey a wide range of tools across the Java, Networking, Filesystem, SOAP, REST, HTML, CSS and JavaScript realms. We'll look at applications such as VisualVM, which help you analyze your heap and garbage collection cycles of both local and remote applications. Performance and load testing tools such as JMeter will expose bottlenecks, threading, and scalability concerns of everything from Java modules to Web Apps (even ones that don't use any Java).

Learn how web service tools such as SOAPui and TCPMon allow you to inspect your SOAP and REST calls at the data structure level, and how Firefox Poster lets you test web services right from the browser. And when only a raw look will do, we can always fall back on the venerable TCPDump. This tool-centric presentation will expose developers to approaches to inspect, debug, tune and troubleshoot Java desktop apps, language-neutral web apps, and framework-neutral web services using Open Source Tools.

By Matthew McCullough

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

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

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

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

By Ted Neward

  So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place.

In this presentation, we'll pick up where the "Platform Security" talk leaves off, and demonstrate how to engage the security model of the JVM at a much deeper level, regardless of your favorite programming language: Java, JRuby, Groovy, Scala, ....

Prerequisite: The Busy Java Developer's Guide to Platform Security

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 Srini Penchikala

Domain Driven Design (DDD) technique helps architects and developers in mapping business domain concepts to software artifacts. When applying DDD techniques in a Java application, there are several domain classes and other artifacts (like configuration files) in Domain, Service and Application architecture layers that can be automatically generated using Code Generation techniques. For example, in a typical web application same data flows through the application layers in different forms like Domain Object (DO), Data Transfer Object (DTO) and XML. The developers usually write these classes manually from scratch or write the first class and then copy and paste when they need the classes for other use cases. These and other classes like Facade, Data Access Object (DAO interface, implementation and the unit test classes) are good candidates for code generation.

Code generation helps the software development process by generating consistent code for the classes and other artifacts that have infrastructure (boiler-plate) logic but don't have any business logic. It fits in very well with Domain Driven Design philosophy of "Domain First, Infrastructure Second" where the developers can focus on business domain concerns and take the advantage of code generation to address the infrastructure concerns. If Domain Driven Design provides the "What", it is the code generation, as a development technique, that can provide the "How". Code generation is a good long-term solution even though this effort involves some initial investment (in terms of coding and time) which pays itself off in medium to large domain models.

This technical session will discuss the role of code generation in a Java web application from the Domain Driven Design and Development context. I will start off the presentation with a quick overview of the Layered Architecture in a typical web application that was developed using DDD design pattern and implemented using Spring Framework (for middleware services) and JPA (with Hibernate3) for persistence. I will talk about the code generation concept in the project, that starts with the creation of a standard and consistent project template (using Maven Archetype feature). The discussion will include a list of the classes we need to write from scratch (like XSD, Domain Object and Service) and then code generate the Java classes and configuration files in domain and other layers (like DAO's, Factories, Repositories, Delegates, DTO's, Unit Tests, and Spring configuration files).

The presentation will include a demo of the Java application to show how domain elements and artifacts can be code generated using tools like openArchitectureWare (oAW), Eclipse, Maven, and Spring. The session will conclude with the design guidelines and best practices to follow when considering code generation as part of implementing a Business Domain Model.

By Srini Penchikala

Even though many companies have some kind of application architecture standards, they don't usually have a mechanism to enforce those standards. As a result of this lack of architecture governance, the Implementation (Code) often doesn't match the Requirements (Reference Architecture). Enforcing Reference Architecture guidelines promotes consistency and modularity in the System. It also helps in detecting structural complexity and preventing it earlier in the software development process. As a result, the application code is modifiable, portable, and testable.

In this presentation, I will talk about the significance of enforcing the architecture rules and standards and how to actually enforce them in software development projects. I will start off the discussion explaining various types of architecture rules that range from simple module dependencies to enforcing how APIs and specific idioms should be used. All these rules usually fall into categories such as Layered Architecture, Separation Of Concerns, Domain Driven Design, and Infrastructure. Some of the rules examples will include basic validations like DAO (Persistence) layer shouldn't depend on any other layers, Presentation layer should not use DAO classes directly, and Service layer should never call web layer. Separation of concerns rules are no transaction management in DAO classes and Service layer should be transactional. More sophisticated rules like that are used in a Domain Driven Design project such as Service object creation through a Factory object (i.e. no Service instantiation using the new keyword), No direct access to DAO's except from the Domain classes (go through Domain or Repository objects), and Business service that fails with a concurrency related failure can be retried.

The presentation will also include the discussion on Static and Dynamic Analysis architecture enforcement setup types and the techniques and tools architects can use for the enforcing the rules. Some of these techniques include Aspect-Oriented Programming (AOP), AspectJ Design Level Assertions (DLA's) and Design by Contract (DbC). As for the tools, Macker can be used for identifying module (package) dependency violations and other tools like Contract4J, SonarJ and Lattix can be used for more comprehensive rules enforcement. The session will include a demo of enforcing architecture rules in a sample Java application using Aspects as well as SonarJ tool. The attendees will be able to take awa

Prerequisite: This is an advanced AOP talk. It assumes the attendees are familiar with AOP and Aspects design concepts.

By Srini Penchikala

This presentation will give an overview of using Aspects/AOP to implement business domain event processing logic and Event Stream Processing (ESP) to analyze the event data streams in real-time. The presentation uses a sample application to demonstrate the use of ESP in a loan processing application. The sample application uses technologies like AspectJ, Spring AOP, and Esper (ESP container) to intercept the business domain events and process them based on pre-defined event processing queries. The application also uses ActiveMQ (JMS), JMX, and Groovy to add asynchronous messaging and application monitoring.

In a typical domain model run-time environment, several business events occur in the business process life cycle. Each of these domain events require further processing to either manage the domain state, notify other business processes, monitor the events or analyze event details for some type of decision-making. There are several reasons why event processing logic should not be coupled with the domain logic. This is where Domain Event Driven Architecture comes to the rescue where the event interception and management logic are defined in separate modules and are dynamically wired together to inject the event logic into the domain implementation code. The event data analysis is done using Ev

Prerequisite: Attendees should have some familiarity with Aspect-oriented Programming (AOP) concepts.

By Nathaniel Schutta

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

By Nathaniel Schutta

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

By Nathaniel Schutta

Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language.

This session will give you an overview of this misunderstood language as well as opening your eyes to some of the excellent tools available to ease the pain of developing in this dynamic language.

By Nathaniel Schutta

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

If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.

The Restlet API was created by a guy who wanted object-level support for RESTful concepts, but didn't want to make the move to an advanced resource-oriented environment like NetKernel. He wanted his REST and conventional environments too. He also wanted a path to more modern containers that aren't tied to a blocking I/O model like the Servlet spec is. This talk will include a brief review of REST and its primary concepts and will then provide an introduction to the Restlet API and how it supports these ideas. It will then focus on standing up a REST-oriented infrastructure using the Restlet API and a variety of other open source tools to support a publish/find/bind infrastructure without to

Prerequisite: REST (unless you are very comfortable with REST)

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

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

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

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.