Workshops

Android is a software stack for mobile devices that includes an operating system, middleware and key applications. Cool apps that surprise and delight mobile users—built by developers like you—are a huge part of the Android vision. In this presentation we will explore many examples of android.

The Android SDK provides the tools and APIs necessary to begin developing applications that run on Android-powered devices. Cool apps that surprise and delight mobile users—built by developers like you—are a huge part of the Android vision. Google has also participated in the Android Market by offering several applications for its services. These applications include Google Voice for the Google Voice service, Scoreboard for following sports, Sky Map for watching stars, Finance for their finance service, Maps Editor for their MyMaps service, Places Directory for their Local Search, Google Goggles that searches by image, and My Tracks, a jogging application. Android phones that include the 'Google Experience' also have Google Search, Google Calendar, Google Maps, Google Navigation and Gmail integrated. In this workshop we will explore many examples of android.

This workshop will provide clear understanding how to build cool applications using Android, which will surprise and delight mobile users. We will explore following areas of android application development:

• Android Architecture • Android Activities and intents • Explore application resources, Views, Widgets, and Layouts • Data and Storage APIs : SQLLite • Developing Cool Application and making it ready as a product • Mobile Development Process • Selling Your Android Application: Making Money

Behavior-Driven Development (BDD) employs the approach of specification by example. Cucumber is such an amazing BDD tool because it’s so good at mapping stories and acceptance criteria to automated functional tests. This is a hands-on workshop using Cucumber-JVM that will have you writing and automating acceptance tests on your own laptop by the conclusion of the session.

This workshop will cover:

• Building quality in
• Understanding the place of BDD - 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 90 minute workshop with Cucumber-JVM 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.

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. In this half-day session you will explore Clojure, a language with many compelling features;

• Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python.
• Clojure's sequence library turns the tables on OO, providing a powerful set of verbs that can work with a small, standard set of nouns.
• Clojure is a Lisp and gracefully supports Lisp's signature feature: code as data.
• Clojure's functional style and support for software transactional memory make it an appealing option for taking advantage of massively parallel hardware.
• Clojure's datatypes and protocols generalize the best idea in OO (interfaces) to handle the expression problem. Say goodbye to wrappers, mixins, adapters, and monkey-patches.

Examples will include hands-on exercises during the session, and more for you to take home.

Many of us have experienced sports coaches, where they helped us stretch for the crawl, turn in dance, or catch a ball. But sports coaching tends to be just one kind of coaching—and not necessarily the kinds of coaching you need to provide or hear at work.

Coaching is one of the most important--and most difficult--responsibilities of leaders. Too often, people struggle and fail when it comes to coaching others. Coaches may try to impose their style on someone else for whom it doesn’t fit. Some coaches try to transfer “best practices” regardless of how well they fit the organization. Other coaches talk too much.

Coaching is a two-way relationship between a coach and the coachee. But not all the learning is on the coachee’s side. If a coach is not learning as he or she proceeds with the coaching, the coach shortchanges the coachee.

We will explore how to recognize when you are the right coach--and when you’re not. We will explore multiple coaching techniques so you can select the ones that most fit you, the other person, and the context. We will practice coaching in several ways and see which ones you prefer, and which ones you might need to practice more. And we’ll see how to learn as you coach.

A Coding Dojo is a place where programmers come to improve their skills, by following a pattern similar to the martial arts dojo. Participants meet for at a pre-arranged time in a room that has one computer attached to a screen. The aim of the exercise will be to add features to an existing (working) web application, using a variety of technologies, such as Hibernate, JUnit 4, JWebUnit, Selenium, easyb and more. Participants will take turns to code, using pair programming and TDD.

During the session, the group spends a pre-set amount of time developing a solution to the challenge. At the end of the session the code is discarded (often it is archived for future reference and study). The amount of time spent on the problem is fixed. Regardless of the state of the solution, when the time expires, the session is done.

Summary: A three-hour, two-part workshop on building modern web applications with the Spring stack.

Detail: In part I, Keith will first provide a brief overview of what Spring offers web application developers. Then, from the ground up, he will take attendees through the process of designing and implementing a web application with the framework.

Attendees will not only learn the Spring feature set, they will learn to apply the features effectively. Whether you are new to Spring, or an experienced Java developer who has used Spring before, this workshop will help you grow as an application developer.

Part I topics covered: Spring Framework v3, MVC, "Open Web" stack of HTML/CSS/JavaScript, JSON, REST & resource-oriented architecture, progressive enhancement, best-of-breed development tools

Part II picks up where we left off by adding an integration layer to the application. This integration layer will allow the application to connect to other systems, as well as push messages to clients asynchronously. Securing the web application will also be addressed. Attendees will complete the session with a broad understanding of using Spring to solve enterprise integration problems.

Part II topics covered: Spring Integration, Ajax Polling/Comet, Spring Security, Open ID-based authentication, Common Enterprise Integration Patterns, best-of-breed development tools

You've heard about Git, Mercurial, Bazaar and the Distributed Version Control System revolution. In this deeply hands on session, we'll load Git on participants laptops, build repositories and share out pieces of work. We'll explore the optimized agile workflows that Git facilitates, building branches for each story card and merging with our team mates, even when a network isn't present. We'll clone an existing Subversion repository, work on it in a Git fashion, and push just the "good changes" back to Subversion, showcasing the incredibly polished interoperability of this radical source code control tool.

This will be a hands on session and requires attendees to bring a laptop (Windows, Linux, or Mac).

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

The demos will span dependency management, test result analysis, code sharing, parallel testing, incremental builds, integrating with Ant/Maven and more.

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.

Groovy is a dynamic language for the JVM; it’s like a super version of Java. For Java programmers, it offers a syntax that closely resembles (in some cases exactly resembles) Java, but offers many improvements that not only greatly simplify code but also provide an enriched environment with many productivity features. In many cases, such features are promised in Java versions 7 and later, but they are available today in Groovy.

Some of the power features of Groovy you’ll learn about are: • Leveraging Groovy’s features to write DSLs • Writing Web Service servers and clients in a few lines of code • Replacing Design Patterns with language features and/or libraries • Talking to the Polyglot world from Groovy: Scala, Clojure, Jython, JRuby, JavaScript and Jaskell • Harnessing constraint/logic and functional programming • Simple but powerful tests • Simplify how you write build tasks • Accessing Hibernate through GORM • Harnessing parallel processing • Leveraging Spring and OSGI

Moore's law has finally hit the wall and CPU speeds have actually decreased in the last few years. The industry is reacting with hardware with an ever-growing number of cores and software that can leverage "grids" of distributed, often commodity, computing resources. But how is a traditional Java developer supposed to easily take advantage of this revolution? The answer is the Apache Hadoop family of projects. Hadoop is a suite of Open Source APIs at the forefront of this grid computing revolution and is considered the absolute gold standard for the divide-and-conquer model of distributed problem crunching. The well-travelled Apache Hadoop framework is curently being leveraged in production by prominent names such as Yahoo, IBM, Amazon, Adobe, AOL, Facebook and Hulu just to name a few.

In this session, you'll start by learning the vocabulary unique to the distributed computing space. Next, we'll discover how to shape a problem and processing to fit the Hadoop MapReduce framework. We'll then examine the incredible auto-replicating, redundant and self-healing HDFS filesystem. Finally, we'll fire up several Hadoop nodes and watch our calculation process get devoured live by our Hadoop grid. At this talk's conclusion, you'll feel equipped to take on any massive data set and processing your employer can throw at you with absolute ease.

Apache Wicket injects fun back into your web application development. The in-depth look went over the components and concepts of Wicket while showing the clear alternative that it provides. Our advanced talk took you through the simple process of interactivity using Wicket's AJAX support and proved that reuse while often promised with other frameworks, is a reality here.

In this hands on, we'll take what was learned in the previous two sessions, and build our own application. Given a project requirement which will be provided, build out a web application in record time using simply Java and HTML. Find out how simple it is to introduce interactivity with Wicket's AJAX support, jazz up your boring forms, and integrate any necessary third party libraries: Java or Javascript, with ease. After this hands on session you'll feel equipped to build out any project in record time using everything learned.

You're adept at Java. You've got a solid grasp of that ecosystem. But you keep hearing about iPhone this, iPad that. It worries you just a bit that you haven't yet spent the time to explore this new frontier. Cure that with a nearly Java-free intense four hour boot camp on the iPad. During this session, you'll use your UberConf-supplied device to get started coding on the XCode platform, learning the Objective-C language, testing, and deploying your apps.

No previous iPad ecosystem knowledge is assumed. Matthew McCullough and Ben Ellingson will take you from the ground up in this unique coding environment. With their hands on teaching style and one-on-one assistance, you'll explore what it takes to build and deploy an application for the iPhone and iPad devices. We'll start with a simple application that you'll code from line 1 to line 200, all the while testing it in the iPad simulator. Along the way, you'll also discover the Developer signup process and digital certificate setup required to push beta applications to the device. Finally, we will integrate an iPad app with data from a JSON web service.

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.

The premise of Nicholas Carr's "Does IT Matter?" book was that if everyone uses the same tools, processes, products, etc., is there any competitive advantage to be had from the average IT organization?

NetKernel represents a fundamentally different approach to building systems. It takes what we like about Unix, REST and SOA and mixes it together. It inexplicably changes everything while allowing you to reuse existing code, services and libraries. Not only can it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.

This workshop will be a deeper dive into Resource-Oriented Computing with NetKernel. We will explore:

• the resource model as it applies to general computing
• the intersection of REST and the resource model
• scaling your software without really trying
• interacting with relational databases
• orchestration around different service types
• logically-layering applications for flexibility
• advanced caching strategies
• leveraging dynamic languages with the resource model
• instant cloud support

It is rare that a technology comes along that is both revolutionary and lets you reuse what you already know. All it takes is a bit of different thinking and a little courage to try something new.

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.

Scala is a very powerful, statically typed, hybrid functional, pure OO language. The strengths of Scala is in its expressiveness, support for XML, powerful pattern matching, and elegant solution to concurrency. In this workshop, you will deep dive into understanding the strengths of Scala from a very practical point of view.

Be prepare to write quite a bit of code in Scala, not simply learning the syntax of the language, but gaining an understanding of the idiomatic differences and capabilities.

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
• Use the Simple Knowledge Organization System (SKOS) to represent taxonomies in RDF
• Model and Do Inference with the Web Ontology Language (OWL)

So you're building a website and want a terrific search experience for your users. Do what your database can't: faceted navigation, result highlighting, fuzzy queries, ranked scoring, spell correction, and more.

Solr, the open-source enterprise search server is the answer. Solr bridges the technology divide between databases and document/web search engines (e.g. Google). Each has its uses but do not overlap.

Chances are you have some structured data, probably in a database, and perhaps some related text documents. When you bring this data into Solr, you'll be able to deliver amazing features. Users will be able to navigate search results by filtering on aggregated attributes (so- called “faceted search”). Furthermore, various features like spell- correcting, auto-completing of search text, boosting records based on various rules, become possible. Solr does not tie you to a particular programming language or computing platform. And whether you have a thousand records or millions and many requests per second, Solr can scale to meet your performance needs. Furthermore, as an open-source solution, Solr doesn't ask you for more money when you want more out of it.

You'll lean the basics of getting started with Solr, and an understanding of what solutions are available to simplifying adding great search to your site!

TBA

In this workshop, you will learn how to create applications that survive the rigors of life in production. Too often, project teams aim to pass QA instead of aiming for success in production. Testing is not enough to prove that your software is ready for continuous availability in the corrosive environment of the Internet.

During this course, you will receive an understanding of the architecture and design patterns that can produce high availability in distributed, multithreaded systems such as those based on Java EE, .Net, or Ruby on Rails. You will also learn about the antipatterns that can sabotage your systems availability and capacity.

There are two reasons to do TDD. One is to ensure the code meets and continues to meet the expectations at the unit of code level. The second, and equally significant, reason is to drive the design of the code. Realizing the first benefit is rather mechanical and comes with rigor and discipline. Realizing the second benefit, however, requires quite some hard work and rethinking. It takes a bit of unlearning to achieve this goal.

In this workshop, rather than preaching the benefits of TDD, we will take an application and develop it using TDD. Developing regular code using TDD is already hard. To a number of us, driving Multithreaded code using TDD is simply unimaginable. Our exercise will help you learn ways to tackle quite easily what appears to be an unsurmountable task for both regular and multithreaded code.