Platinum Sponsors
ÜberConf 2011 Brochure - Download
Proud Supporter of:
Workshops
with Ian Robinson and Jim Webber
Graph databases are an esoteric but powerful member of the NoSQL family. For highly connected data, graph databases can be thousands of times faster than relational databases, making Neo4j popular for managing complex data across many domains, from finance to social, telecoms to geospatial.
This tutorial covers the core functionality from the Neo4j graph database, providing a mixture of theory and accompanying practical sessions to demonstrate the capabilities of graph data and the Neo4j database. Specifically, you'll learn about:
- NoSQL and Graph Database overview
- Neo4j Fundamentals and Architecture
- The Neo4j Core API
- Neo4j Traverser API and declarative querying
- Graph algorithms
- Alternative Language Bindings [optional, depending on time]
- The Neo4j REST API and using the database from non-JVM platforms
- Solutions architecture: using Neo4j in large systems
Each session (apart from the fundamentals and architecture) will be a mixture of a small amount of theory combined with a set of practical exercises designed to reinforce how to achieve sophisticated goals with Neo4j. The practical parts of the tutorial consist of Koan-style lessons where a specific aspect of the Neo4j stack is presented as a set of failing unit tests which participants will work to fix, gradually becoming more challenging until the attendees are capable of implementing sophisticated graph operations against Neo4j.
Attendees won't need any previous experience with Neo4j or NoSQL databases, but will require some fluency in Java, a little familiarity with a modern IDE, and a basic understanding of JUnit to help complete the lab tasks.
with Ted Neward
First there was iPod. Then iPhone. Then iPad. And with each new release, the mobile device market grew hotter and hotter. Now, as Google’s entry into this race, the Android system, begins to hit its stride as a competitor platform to the iOS, as a Java developer you’re intrigued—it’s Java (well, assuming you ask anybody except Oracle), and it’s a mobile device, and it’s open source, and…. What’s not to love?
In this all-day workshop, we’re going to turn you into a journeyman Android developer. This is a Java-based platform, so we’ll have a leg up on those other “Java-free” environments where you’ll have to spend half the day just learning how to count from 1 to 10 and print it to the console all over again. We’ll start by looking at the Android toolchain and how it integrates with your existing toolchain (Eclipse or otherwise). We’ll get your hands dirty writing some code to the Android emulator, then (for those of you who have Android devices handy) push it to a device. We’ll write some unit-tests for testing an Android application. We’ll look at how to store data to the device, both in a SQLite database as well as to a straight file. We’ll look at how to make Internet calls to remote services, and when all is said and done, we’ll have an application that Really Works (TM). Bring a laptop, your Java skills, an Android device if you’ve got one, and buckle in, because it’s going to be a straight-from-the-firehose kind of workshop.
with Ted Neward
Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.
The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.
In this session, attendees will be split into small groups and given a "real world" business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate--the great architect has no need of tools, just their mind and the customers' participation and feedback.
with Paul Rayner
Acceptance Test-Driven Design (ATDD), or Behavior-Driven Development (BDD), employs the approach of specification by example. Cucumber is such an amazing ATDD tool because it’s so good at mapping stories and acceptance criteria to automated functional tests.
Product Owners, developers and testers collaborate together to write acceptance criteria in natural language and unobtrusively automate tests for them. This is a hands-on workshop that will have you writing and automated acceptance tests on your own laptop by the conclusion of this session.
Cucumber enables a team to collaboratively create specific examples that specify what the system should do from the user's perspective. These executable specifications function as acceptance criteria for the user stories the team is developing. This workshop will cover:
- Building quality in
- Understanding the place of ATDD - The agile testing matrix.
- Why test automation?
- Build the right product using specification by example
- The need for Ubiquitous Language
- Writing scenarios with Cucumber
- Using Cucumber to test web applications
This is a hands-on 3 hour workshop with Cucumber using Java, you will need a laptop running the JDK and a text editor (doesn't have to be an IDE). Class tools, materials and code exercises will be provided.
with Jez Humble
The first 1h30 will introduce the value proposition of continuous delivery, and present the deployment pipeline, the key pattern at the heart of continuous delivery.
The second 1h30 will discuss creating and maintaining automated tests, and continuous integration and patterns for developing on mainline such as feature toggles and dark launching.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this tutorial we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. There will be interactive exercises where the audience practices using these techniques for themselves. At the heart of the tutorial is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the tutorial introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
with Jez Humble
In the 3rd 1h30, we will discuss componentised or service architectures, patterns for low-risk releases, and agile infrastructure management.
In the 4th 1h30, I cover data management and organizational transformation. If there's time, there will be a bonus session on architectural patterns.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In the second half of the tutorial, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
with Tim Berglund
Take one ugly legacy schema, a toolbox full of simple database refactorings, and a world-class schema refactoring tool, and you've got 90 minutes of workshop that will equip you to bring a culture of database responsibility to your team.
In this workshop, we'll start with a live schema in need of some help, and slowly improve it in a controlled fashion using Liquibase. We'll see how to create and alter tables, add constraints, drop columns, control changes in stored procedures, and more. You should come away with a solid understanding of how to use the tool and how to integrate it into your team's development, build, and deployment processes.
Attendees should already have a conversational understanding of Liquibase, or have attended Scripting the Schema with Liquibase session. Please bring a laptop or be prepared to pair with a friend.
with Venkat Subramaniam
Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.
The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will also leave with confidence to debug and to improve the performance of your Apps.
with Tim Berglund
Once you've been introduced to Gaelyk and the Groovy way it wraps the services the Google App Engine, it's time to write some code. Bring your laptop for a hands-on Gaelyk hack session in which we build a working Gaelyk app utilizing as many of the GAE services as we can pack into a 180 minutes of coding!
Workshop attendees should have a laptop with the following: JDK 5+, an IDE or editor capable of editing Groovy code and HTML, the Google App Engine SDK already downloaded and installed (http://code.google.com/appengine/downloads.html#GoogleAppEngineSDKfor_Java), and the current version of the Gaelyk project template (https://github.com/glaforge/gaelyk/downloads).
with Matthew McCullough
Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.
The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.
with Peter Niederwieser
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.
n the Java build space, first there was Ant, which provided a reliable way to build without an IDE. Then there was Maven, which gave us standardization in build lifecycles and dependency management. Now... Enter the Gradle and find yourself immersed in a rich build language with the flexibility of Ant, the declarativeness of Maven, and a new level of sophistication that takes your builds further than ever before.
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.
with Dave Klein
The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.
Rather than try to learn Grails feature by feature, we’ll let it unfold as we build the application. We’ll begin with a simple application structure that runs right out of the box, then we’ll gradually build our application while building our knowledge of Grails. Bring your laptop and be ready to code.
We will be using Grails 1.3.5 for the exercises.
with Dave Klein
In Part II of this session, we will continue the build out process with the Grails application.
When we’re done, you’ll have learned about:
- Grails Domain Classes
- Dynamic scaffolding
- Grails Controllers
- Groovy Server Pages
- GSP Tags
- Grails Object Relational Mapping (GORM)
- Dynamically Injected Service Classes
- Grails’ Javascript and Ajax Support
- URL Mapping
This is an introduction, but it is also a deep dive. So bring your laptop and be ready to code.
We will be using Grails 1.3.5 for the exercises.
with Venkat Subramaniam
In this workshop we will take some common everyday tasks and learn how to program it using Scala.
There will be short (ten to fifteen minutes) lecture sessions followed by hands-on exercises where the attendees will pair up to implement tasks and in the process learn the strength, expressiveness, conciseness, and the power of Scala.
with Brian Sletten
People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the "HTML 5 and the Kitchen Sink" discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them.
We will work with real code covering:
The new input elements Editable content Canvas Element and its related 2D APIs for drawing and animation Audio and Video elements and how to use fallbacks for codec coverage Browser native drag and drop Local storage Web Workers Websockets The Geolocation API Web DB (SQL in the browser!) This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.
Bring your laptops. This is a hands-on workshop.
with Esther Derby
It’s not easy to build the right product. People sometimes don’t know exactly what they need, want things that won’t help, and don’t imagine what’s possible. Agile project capture requirements on cards that contain a statement of want and benefit and notes on how to confirm the need is met. The intention isn’t to fully document the requirement on the card, but to make a note and create a reminder for a conversation with the customer. Whether you are using agile methods or traditional requirements, valuable products start with understanding the customers context, their problems, what they want, and how they use a product. However, most people aren’t born with the ability to speak naturally in user stories or fully formed requirements statements. So we must learn how to ask the right questions, draw out pertinent information and understand the customer’s world in those conversations.
In this session, you’ll learn about different types of questions, and when to use them to learn about how the customer currently uses a product, the problems they experience with the product, and problems that new features in the product might solve. Then, we’ll put that to work in practice interviews.
with Brian Sam-Bodden
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
with Brian Sam-Bodden
This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.
In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment
with Neal Ford
Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This workshop describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This workshop also demonstrates some areas where it makes sense to mixin Ruby and Java code: building swing applications, testing, and dynamic programming.
This workshop includes tons of examples, including side-by-side comparisons of Java and equivalent JRuby code. It also covers some more advanced topics like building domain specific languages, meta-programming (including real uses!), and more.
with Kirk Knoernschild
Modularity is coming to the Java platform! But contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!
In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.
with James Carr
You might have heard a bit about nodejs, now it's time to get fully immersed in it and not just learn it in detail but gear up to start becoming an active member of the nodejs development community.
We'll show you how to get started at creating your own node modules and how to package them up for distribution. This will be a hands on lab to get all the essential tools setup and at the end you will have a package that anyone can install via npm (thing of ruby gem for nodejs) and start using right away.
Since node.js currently doesn't work on plain windows, you will need a laptop with BSD, Linux, OSX or if you have windows you will need cygwin installed with common development tools (g++, python, make, etc).
with Ted Neward
Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)... it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.
After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.
with Venkat Subramaniam
Starting threads is easy, benefiting from them without being burnt is hard. The multithreading API in Java has evolved quite a bit since the early stages. There are three options for concurrency in pure Java today: the modern JDK API, the Software Transaction Memory, and the actor based concurrency. In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
with Ian Robinson and Jim Webber
The Web is fast becoming a serious competitor to traditional enterprise architecture approaches. This full day workshop will provide an introduction to RESTful Web Service techniques, both from a theoretical and practical perspectives.
This full day workshop is broken down as follows:
- Introduction and Motivation
- The Web Architecture
- Simple Web Integration including POX and URI tunnelling
- CRUD Services using URI templates and HTTP
- Semantics using Microformats and RDF
- Hypermedia and the REST architectural style
- Scalability and how a text-based client-server polling protocol outperforms everything else!
- ATOM and ATOMPub for event-driven and pub/sub applications
- Security
- Conclusions and further thoughts
Participants should be comfortable with distributed computing concepts, but won't need any particular integration or middleware experience
with Brian Sletten
The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level Apply Web and Semantic Web technologies in the Enterprise and make them work together Integrate structured and unstructured information Create good, long-lived logical names (URIs) for information and services Use the Resource Description Framework (RDF) to integrate documents, services and databases Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)
Bring your laptops. This is a hands-on workshop.
with Erik Hatcher
Solr Recipes provides quick and easy steps for common use cases with Apache Solr. Bite-sized recipes will be presented for data ingestion, textual analysis, client integration, and each of Solr’s features including faceting, more-like-this, spell checking/suggest, and others.
Quick and easy steps for common Apache Solr use cases
Ingesting recipes: CSV, relational databases, file system, web crawls, API
Analysis recipes: copyField, character mapping, tokenizing and filtering, configuring for suggest, data exploration
Faceting recipes: field, date and numeric range, pivot, and query faceting
Integration recipes: prototyping user interactions, working with Solr from PHP, Rails, Java, Ajax, and other environments
Other featured recipes: more like this, spell checking/suggest, grouping, clustering
with Craig Walls
For as long as there has been a Spring Framework, there has been Spring MVC, a web framework built around the principals of Spring. Although it was originally designed around a deep hierarchy of controller classes and focused on HTML-oriented views, Spring MVC has evolved in the past few years to embrace an annotation-oriented model and RESTful web development.
In this workshop, we'll use Spring MVC to build the web front-end of an application. We'll start with the essentials and work our way up to try out the latest Spring MVC features in Spring 3.1. We'll explore the following Spring MVC topics:
- Spring MVC essentials (request mapping, controllers, and views)
- Field formatting and validation
- Spring's JSP tag libraries
- Handling file uploads
- Content negotiation and non-HTML views
- Request and response body conversion
- Advanced request mapping
- And much more!
Whether you're a Spring newbie or a long-time Spring veteran, this is your chance to get a hands-on experience with everything Spring MVC can do.
IMPORTANT!!! PRE-WORKSHOP SETUP INSTRUCTIONS!!!
In order to ensure a successful workshop, it is imperative that you arrive with the following installed on your computer:
- Java SDK 1.5 or higher (not the JRE!)
- Maven 3.0.3 (or newer): http://maven.apache.org/
- SpringSource Tool Suite (2.8.0 or higher): http://www.springsource.com/developer/sts
Also, before arriving, it will save time if you have already verified this setup. As part of the verification, perform the following steps:
- Start SpringSource ToolSuite
- Create a new Spring MVC template project (File->New->Spring Template Project, then select "Spring MVC Project"). Name the project "SpringMVC". (Note that if this is the first time you've created a Spring MVC template project, it may take some time to download the templates.)
- Once the project has been created and has had a chance to build in the IDE, drag the project into the tcServer instance ("VMWare vFabric tc Server Developer Edition v2.6") in the "Servers" tab.
- Start tcServer
- After the server starts fully, point your browser to http://localhost:8080/SpringMVC and verify that you are greeted with a "Hello World!" message along with the current time.
We will not have time during the workshop to setup your environment, so please arrive having performed these setup steps. If you need any help getting started, feel free to email craig-mvcws@habuma.com and I'll do my best to help out.
with Craig Walls
In this hands-on workshop, we'll work together developing a Spring application using Spring Roo.
To fully benefit from the workshop, you should bring your computer loaded with Java 6 and Spring Roo 1.1.0 and SpringSource ToolSuite 2.5.1.
with Dave Klein
You've probably heard about Groovy, the dynamic language for the JVM. You may have heard that Groovy is what Java would have been if it had been written in the 21st century. Maybe you've even seen some demos of the seemingly magical things that you can do with Groovy. Well, now it's time to download the bits and experience the fun and productivity for yourself.
In this hands-on tutorial, we'll highlight some of the key features of Groovy by working through some real-world assignments. In Part 1, we'll work with Groovy Objects, GStrings, Closures, and Groovy Collections. Then in Part 2, we'll see how Groovy can make things like XML, JDBC, and even Swing easier than ever.
This is a hands-on workshop; please bring a laptop with JDK 5 or higher installed.
