Estimating vs. Guessing - How Agile Teams Estimate Their Work

Estimating is regarded as little little more than 'educating guessing', but so much can hang on the quality of those estimates. With good estimates we can set clear expectations for project delivery, but with bad estimates we can run over schedule and over budget, or worse. We often estimate when we know the least about the work that needs to get done - so how can we make the best of what is potentially a bad situation?

Maintaining Source Code Quality (The Project Integrity Series)

How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? Have you ever been the 'new guy' on a project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.

Managing Complexity (The Project Integrity Series)

Watch Preview Video

How many times have you started a new project only to find that several months into it, you have a build process that mysteriously fails, a bunch of 'TODO' and 'FIXME' comments in the source, and problems that come and go because "it works on my machine"? Does your project have a little bit of 'folk wisdom' that isn't well-known, but is necessary to get things done? How easily could you recreate your development environment if you got a new machine today?

Groovy Testing

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

Groovy XML Ninja Skills

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

RESTful Grails

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

The Amazing Groovy Weight-loss Plan

"The central enemy of reliability is complexity." (Dr. Daniel Geer)

Java is a powerful programming language. A smart developer can do nearly anything with Java. So the next question is, "How quickly can it be done? How many lines of code does it take to do common tasks?" Groovy greases the wheels of Java by decreasing the complexity of the language while preserving the raw power. At first glance, you might think that this talk is simply about how Groovy drastically reduces the lines of code you need to write. What this talk is really about is bringing simplicity, clarity, readability, and yes, beauty to your source code.

Web 2.0 Checklist: Deconstructing Modern Websites

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

Architecting Code for Concurrent Execution: Theory and Practice

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.

Grails for the Enterprise

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.

The Concurrency Toolset: JConch, Google Collections, and java.util.concurrent

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.

Emergent Design & Evolutionary Architecture

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.

Real-world Refactoring

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.

Unit Testing that Sucks Less: Small Things that Make a Big Difference

Unit testing seems to a lot of managers and developers like pure overhead, but professionally responsible developers know that it is one of the keys to quality. This session covers a bunch of small tools that makes testing easier & faster. I talk about tools like Infinitest, Jester, MockRunner, Hamcrest, Groovy, RSpec/EasyB, Selenium, and others. While none of these tools is elaborate enough for it's own session, together they add up to more than the sum of the parts. This session shows tools and strategies to streamline testing, making easier and more palatable for both managers and developers.

Visualizations for Code Metrics

Judicious use of metrics improves the quality of your code. But interpreting metrics presents a challenge. You have a list of numbers for a project - what does it mean? And what does it tell me about the health of the project overall? This sessions shows how to produce visualizations for software metrics, making them easier to understand and more valuable. It covers metrics at the individual method level all the way up to the overall architecture of the application. This isn't just a talk about how some tools produce visualizations: this session shows you how to generate your own visualizations, allowing you to customize it to the level in information density that shows real value on your project. I show how to produce projected graphs from dependencies, heat-maps for cyclomatic complexity and code coverage, using XSLT to extract visual information from XML configuration documents, and others. Metrics can't help you if you can't understand them. By creating visualizations, it helps leverage metrics to make your code better.

Flex for Java Developers

An introduction to Flex for Java developers.

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

GWT fu, Part 1

Learn to implement web applications with GWT.

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

GWT fu, Part 2

Learn to do amazing stuff with GWT.

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

JSF 2.0: Advanced Topics

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

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.

JSF 2.0: An Introduction

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

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

Easy BDD with Groovy

The Manifesto for Agile Software Development essentially focuses on meeting customer needs through reducing wasteful activities. For example, Agile developmental practices push for reducing repetitive documentation and for a rapid acceptance of change; yet, achieving these goals is by no means easy. While a process can enable increased collaboration, for instance, there are various tools that can effectively implement Agile principles. Once such tool is easyb (www.easyb.org), which is a Groovy based domain specific language, which facilitates collaboration by bridging those that define requirements (i.e. customers) and those who turn requirements into code (i.e. development). With easyb, collaborative teams can develop stories in a specific format which are then implemented as tests through a framework which marries the underlying application. This test suite enables change and produces accordance among Agile teams in short order.

Leveraging the cloud with Amazon Web Services

Amazon's S3 and EC2 offerings are publicly available services that enable you to run virtual machines and store (and retrieve) digital assets (i.e. images, music, documents, etc). In this session, we'll cover the ins and outs of S3 & EC2 and see first hand how to leverage them for various purposes -- either personal or in the enterprise.

Tactical Continuous Integration with Hudson

This session will walk attendees through a series of iterations on a fictional Java project where an automated build system is created that facilitates compilation, testing, inspection, and deployment. This build system is then plugged into the Hudson CI server and as features are coded using Agile techniques like developer testing, attendees will ultimately see firsthand how a Continuous Integration process reduces risk and improves software quality.

Agile Retrospectives

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.

Clojure

In recent years, the Java community has embraced a variety of new languages that target the JVM, but also offer productivity advantages over traditional Java coding.

IZero: Starting Projects Right

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.

Java.next: Clojure, Groovy, JRuby, and Scala

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.

Acceptance Test Driven: Beyond the Geekdom

How testable are your requirements? If they are user stories, you have better odds than others, but you may still struggling to increase your automated feature testing. Acceptance test driven (ATD) means understanding the needs or the value before you start coding, and it is often hard to make ATD sticky in organizations.

While tools and geekology are needed, the upstream flow with the larger project community must exist to be successful. The session will teach you how to spark ATD from idea to code, connecting the dots and the players along the way. From product concept to automated tests, we will discuss and practice various ways to connect business, development and testing around the creating and getting value from ATD.

Agility as a Tool: Getting Ready to Iterate

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.

Architecture and Agility Are Not Enemies

Being agile does not mean living life one iteration at a time. Agile projects without a long view can run into the common design problems of the past. Planning iteration by iteration is often foolish and feeds the myth that agile projects do not think beyond a few weeks. Successful agile projects plan within iterations and across iterations. The later planning is called release planning and it is the forum where agility first engages architecture and other cross cutting concerns.

Discovering Real Value with Story Maps and Personas

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.

What Is Lean and Why Should You Care?

Whether it was intentional or not, the agile community has been borrowing successful ideas from the lean manufacturing for years. Lean practices, like finding and removing wasteful work, can be applied without needing special permission or certification. Ideas like kanban (visual planning aids) and kaizen (continuous learning) are simple, helpful tools that are easily applied and produce great results.

Groovier Spring (More Flexible Applications With Spring and Groovy)

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.

Polyglot Persistence

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.

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

Real World Hibernate Tips (Reloaded)

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

Prerequisite: Basic understanding of Hibernate.

Spring 3.0 Overview

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.

Prerequisite: Basic understanding of Spring framework.

Git Going with Distributed Version Control

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.

Prerequisite: Basic understanding of Subversion or similar version control system

Mastering Maven 2.0

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.

Prerequisite: Basic Maven knowledge

Open Source Debugging Tools for Java

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.

Open Source Debugging Tools for Web Apps

This session will survey a wide range of tools across the Web application debugging space, covering the REST, HTML, SOAP, CSS, TCP, Filesystem and JavaScript facets of an app. We'll look at utilities such as tcpdump, curl, Wireshark, JMeter, Firebug, JASH, Poster, SoapUI, Firediff, lsof, fs_usage, iwatch 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.

iPhone Objective-C with Java Web Services

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.

Busy Developer's Guide to Iconoclasm

History is littered with the stories of iconoclasts--people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes--and their successes and failures. From the baseball management vision of Branch Hickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly.

Busy Java Developer's Guide to Advanced Collections

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?

Prerequisite: Busy Java Developer's Guide to Collections

The Busy Java Developer's Guide to Advanced Platform Security

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.

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

The Busy Java Developer's Guide to Collections

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.

The Busy Java Developer's Guide to Functional Java

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.

The Busy Java Developer's Guide to Java Platform Security

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.

Architect for Scale

Is your system small, medium, large, or super-size? Is traffic on it's way up?

Architecture patterns and structures that work at one scale seldom work across all of them. A communication style that's appropriate for small websites will probably fail badly if you apply it to world-wide networks of computers. Likewise, structures that work for large-scale systems are probably too complex and expensive to be worth it for small sites.

DSLs in Scala: Internal and External

We're no longer working in a single language. Programming today is about both consuming and creating languages.

We've all heard a lot about domain specific languages (DSLs). So much so, in fact, that it seems like more people are talking about it than doing it. In this session, Michael will present a real domain with familiar problems. He'll then demonstrate both an internal DSL and an external DSL that solve the same problem. Along the way, we'll cover fluent interfaces, composing multiple DSLs, and the very cool parser combinators.

If you've ever left a DSL talk wondering when we're ever going to get past the "coffee ordering DSL" or the "Waffle House breakfast DSL", then you will want to see this session.

Prerequisite: None.

Design for Operations

If your software fails in production, nobody will care how great the development project was, or how well the system passed QA. Production operations, the domain of your systems' least-appreciated stakeholders, is where the rubber meets the road. Come learn how to build your systems to thrive in Operations.

Advanced Topics in JMS

This session covers some of the more advanced features of JMS messaging, and is intended for those who are familiar with JMS and messaging in general. Some of the topics I will be covering in this session include message grouping (where I will demonstrate sending a large JPG image using messaging), transacted sessions, client-based acknowledgement, and some various messaging design considerations and things to watch out for from a design and coding perspective. I will be doing live coding demonstrations to illustrate the techniques described in this session. Although this session is entirely JMS provider agnostic, I will be using ActiveMQ, a popular open source JMS provider, during the live coding demonstrations.

Prerequisite: Some knowledge of messaging and JMS would be helpful

Common AntiPatterns and How To Avoid Them

In the book "97 Things Every Software Architect Should Know" (O'Reilly, 2009) I wrote about the importance of design patterns as a useful means of communication between architects and developers. Equally important to patterns is an understanding of AntiPatterns - things that we repeatably do that produce negative results. AntiPatterns are used by developers, architects, and managers every day and are one of the main factors that prevent progress and success. In this session we will look at some of the more common and significant development and architecture antipatterns. Through coding and design examples, you will see how these antipatterns emerge, how to recognize when the antipattern is being used, and most importantly, how to avoid them. By attending this session, you will be part of a movement to reduce the AntiPattern catalog from hundreds of entries to only a few.

Prerequisite: None

Introduction to JMS

There's no doubt about it - messaging is quickly becoming a standard part of most application architectures, particularly as more and more companies struggle to find ways to integrate heterogeneous environments due to mergers, acquisitions, or to streamline existing application portfolios. The Java Message Service (JMS) API allows Java applications to implement messaging using a standard API, therefore removing the dependency of any particular messaging provider. In this introductory session we will take a look at the basics of messaging and the JMS API. I will start by discussing the different messaging models, the structure of a basic JMS message, and the JMS API interfaces and how they interrelate. Then through interactive coding I will show the basics of sending and receiving messages using the point-to-point messaging model and how to do request/reply processing. NOTE: this session is meant to be an introduction to messaging and JMS - no prior JMS or messaging experience is needed for this session.

Prerequisite: None

On Being a Software Architect

One way to stop a conversation dead while at a party or gathering is to mention you are a software architect. Why? Because it takes about an hour (complete with Powerpoint slides) to explain what you do for a living. By then the person you are talking to is so bored they would rather sit in a corner licking nine-volt batteries. The problem is that no one inside or outside our industry really knows what a software architect is or what they do. In this highly interactive (and slightly humorous) session we will take a deep dive into the role a software architect plays in the IT industry. We will explore the characteristics an architect needs to have, and the elements that make a good architect and a bad architect. Through amusing antidotes and real-world examples, we will see how to become an effective software architect and help shape the industry in terms of the role and title of software architect.

Prerequisite: None

Transaction Pitfalls and Strategies

In previous years I have given sessions related to my book "Java Transaction Design Strategies", where I have reviewed the basics of programmatic and declarative transactions and outlined the basic patterns described in the book. In this new session for 2009 I will focus on some of the pitfalls encountered while dealing with transactions and then how to develop an effective transaction strategy. I will start this session by describing and illustrating some of the common pitfalls I continue to see in both Spring and EJB. I will then describe four common transaction strategies you can use and implement, including a transaction strategy for high-speed transactions, a transaction strategy for client orchestration, a transaction strategy for use with API's, and finally a strategy for highly concurrent environments.

Note: This session assumes you know a little bit about transactions and have been using them in either Spring or EJB. It is not intended to be an introductory session on how transactions work. You can obtain a free PDF download of my transaction book at http://www.infoq.com/minibooks/JTDS to quickly come up to speed with transactions.

Prerequisite: Java, Spring or EJB; some knowledge of transactions and JTA.

REST : Information-Driven Architectures for the 21st Century

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.

Rich Web Pages : Publishing Semantic Content with GRDDL and RDFa

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.

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

SPARQL: Querying the Data Web

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.

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

Semantic SOA : Meaningful Service Strategies

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.

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

Building External DSLs

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.

Cleaning up Code Smell

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.

Effective Java

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.

Programming Scala

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.

Tackling Concurrency on the JVM

Watch Preview Video

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.

Collaborative real-time RIA

In this session, learn to craft and create collaborative rich internet applications, that are responsive and updated in real-time for streamlined decision making and business intelligence harnessing. Understand how in-time communication can smoothen information exchange, reduce errors and increase productivity.

Flex and Hibernate

A complete journey into the challenges and solutions for effective integration of Flex and Hibernate.

Flex and Java integration

Flex is a leading rich internet application development framework and Java is the most pervasive of enterprise computing envirnments. In this session you will learn to combine the two effectively and leverage a robust server side with a highly interactive user interface.