QCon SF 2014: over 12 tutorial options
The tutorials for QCon San Francisco 20104 will take place on November 6th and 7th.
There will be half-day and full-day tutorials, with over 12 options.
Tutorial Selection Refund Until Sept. 15th
Want to buy tutorials but concerned that you don’t know what the final tutorial list will be yet? The full schedule will be up over the summer. If you buy now and find that you’re not interested in the tutorials published by September 15th, 2014, we will promptly refund your tutorial ticket price - no questions asked.*
*Tutorial refund requests should be sent to email@example.com by Tuesday, September 15th, 2014 to be eligible.
You’ve heard the hype about Docker and want to see it in action? This tutorial is for you. It will introduce you to Dockerand take you through a fast-paced course, using a real Docker installation.
You will learn how to operate Docker and containers, and integrate them into your development and operational workflow.
We’ll explain why Docker exists and why you should care about it. We’ll then take you through a variety of hands-on exercises designed to turn you from a Docker beginner into a seasoned user including:
- Creating our first Docker container
- Building Docker images with Dockerfiles
- Storing and retrieving Docker images from the Docker Hub
- Running containers from images
- Using Docker for sandboxing and testing
- Deploying applications with Docker
By the end of the tutorial you will be familiar with the why of Docker. You will also be able to perform most of the basic tasks needed to get started with Docker and integrate it into your working environment.
Each person attending will be provided with their own virtual machine for the duration of the training, with Docker pre-installed and pre-configured.
Tutorial level: Beginner
Basic Unix command line knowledge
A laptop with a SSH client
Managing, monitoring, and improving application responsiveness is a common need for many software professionals. Whether you develop Java applications or manage them, understanding application responsiveness and the major mechanisms that affect it is key to achieving successful applications and happy users. In this workshop, Gil Tene (CTO, Azul Systems) will provide an in-depth overview of Latency and Response Time Characterization, including proven methodologies for measuring, reporting, and investigating latencies, and and overview of some common pitfalls encountered (far too often) in the field. While most of this discussion will apply to all application environments, some specific considerations in JVM based environments will be covered as part of this workshop.
Our discussion will include an exploration of of the common needs and motivations for understanding the behavior of application response time and latency, and ways to successfully capture these descriptions and relate them to business needs. However, even good characterization of bad data is useless. If measurements of response time present false or misleading latency information, even the best analysis can lead to wrong operational decisions and poor application experience. Gil will demonstrate and discusses some common pitfalls, false assumptions and problematic measurement techniques that lead to dramatically incorrect reporting results, and will explain how these false measurements naturally occur using the most common measurement methods and tools in use today. We will discuss the coordinated data omission problem, and ways to work around it, and will introduce and demonstrate how simple and recently open sourced tools can be used to improve and gain higher confidence in both latency measurement and reporting.
Garbage Collection, in platforms that use it, is often dominantly responsible for application responsiveness and latency behavior. Gil will review and classify the various garbage collectors and collection techniques available in managed runtimes today. We will define terms and metrics common to all collectors, classify some commonly available collector mechanisms, and discuss the tradeoffs involved in balancing responsiveness requirements against other concerns (like throughput, space, etc.). We will include an interactive discussion of how these tradeoffs play off in the real world.
Who should attend:
Software developers, architects, technical leaders and anyone with an interest in designing or measuring for latency in software environments.
Java 8 has been released with loads of exiting new features. To celebrate the release, bring your laptop and learn all these new features through hands on coding exercises.
By the end of the day we promise that you will have written some Java 8 code and learned how to use Lambdas in Java. The tutorial will rapidly alternate between lecture style presentation and hands on coding exercises.
- Java 8 Lambda Expressions
- Java 8 collections and streams api
- Java 8 concurrency enhancements
- Java 8 generics enhancements
- Java 8 Annotation & Reflection Enhancements
- Java 8 Date and Time apis
- Java 8 usage examples with Spring 4.0
Prerequisites: You are comfortable programming in Java. Bring a laptop configured with the all the required software.
- Operating System: Windows, Mac or Linux
- JDK : Download and install the latest JDK 8 for your OS from the oracle website or your linux distro
- Download an install a Java 8 capable IDE latest IntelliJ, NetBeans or Eclipse
- Eclipse users, please choose one of:
What does a mouse drag event have in common with an Array of numbers?
The answer to this question may surprise you: they are both collections. This key insight holds the key to dramatically
to create surprisingly expressive asynchronous programs. Using just a few functions, you will learn how to do the following:
- Declaratively build complex events out of simple events (ex. drag n' drop)
- Coordinate and sequence multiple Ajax requests
- Reactively update UI's in response to data changes
- Eliminate memory leaks caused by neglecting to unsubscribe from events
- Gracefully propagate and handle asynchronous exceptions
Prerequisites: Attendees need to bring their laptop and a WebKit-based browser.
Java 8 is a landmark release because it introduces the powerful new Stream library to the JDK. Streams make it easy to describe data transformations and split them across multiple threads to boost speed.
In this class you'll learn how to transform Java 8 Streams with closures. Then we'll teach you how to use the exact same API to transform Reactive Streams.
Reactive Streams are streams of data that arrive asynchronously, and they are part of Netflix's popular open-source RxJava library. Reactive Streams go beyond Java 8 Streams, allowing you to process data without blocking. Using Reactive Streams you can easily build non-blocking web servers with dramatically improved throughput and smaller thread pools.
Join us and learn how to use one simple programming model to harness parallelism and coordinate event-driven systems!
Haven't used Gradle in practice? This workshop is the perfect hands-on introduction that equips you with a solid foundation.
This two-part hands-on Gradle workshop covers topics such as: Fundamental Gradle concepts, getting started with Gradle, authoring build scripts, using tasks and plugins, building Java projects, automated testing, and multi-project builds. About half of the time is spent on practical exercises, so don't forget to bring your laptop! Pairing is encouraged.
Prerequisite: This course assumes a good understanding of the Java language. Some code is initially easier to understand if you also have a basic understanding of the Groovy language. But due to Groovy’s similarity to Java, Groovy is not a prerequisite. JDK 6 or higher should be installed and a text editor of your choice.
In this tutorial I’ll introduce some of the Big Data technologies we use at Pinterest to analyze petabytes of data each day. We’ll walk through a basic setup of a data pipeline using AWS S3, Hadoop on EMR, and Redshift. We’ll then do some analysis and look at the tradeoffs between the two.
- What is big data? When do you need these technologies?
- Load and interact with data in S3
- Launch an EMR cluster
- Analyze your data using Hive
- Launch a Redshift cluster
- Load data into Redshift
- Analyze your data using Redshift
Tutorial level: Intro
Participants should be comfortable with editing files from a shell, have some basic SQL experience, and have some knowledge of a scripting language like Python.
This is a full-day tutorial in writing iOS apps in the new language Swift using the Xcode IDE on Macintosh. An iPhone or iPad app is made of intercommunicating objects belonging to Apple's Cocoa Touch frameworks.
Learn to create and destroy these objects, connect them together, and call their methods. Use them to draw text and graphics on the screen, perform simple animations, display controls such as buttons and sliders, respond to a keystroke or other touch, and recognize a gesture such as a swipe, tap, or pinch.
We concentrate on three iOS design patterns.
1. An object can call a method of its delegate object in response to a changing situation, e.g., upon reaching the end of an audio file during a playback.
2. A control object (e.g., a button or slider) can call a method of its target object in response to a touch.
3. A view controller object can create and call the methods of the view object underneath it, and forms the connection between the view object and the rest of the app.
Tutorial level: intermediate.
Prerequisites: Requires previous programming experience, but not necessarily in the language Swift. The examples will be displayed and run on a Mac during the tutorial, and registrants can bring their own Macs if they'd like to run the examples for themselves.
Swift requires at least Xcode 6, which in turn requires at least OS X 10.9.3.
You'll be introduced to the Web Components family of specs (Custom Elements, Shadow DOM, HTML Imports, and Templates), learn best practices for Web Component development, and walk out having coded your very own component.
There will be time allotted for tips and tricks, along with questions and discussion of all things Web Components.
Web Components are a set of intermediate to advanced APIs/specs that touch some of the more complex areas of the DOM and internal browser mechanics. I'll be attempting to get beginners briefly up to speed, then focus on intermediate use-cases, and a few advanced tips.
Prerequisites: up-to-date copy of Chrome or Firefox Nightly.
In this tutorial, we will provide a brief overview of NodeJS, including its strengths and weaknesses, best practices, and package management. After the introduction, attendees will have the remainder of the tutorial to learn NodeJS through hands-on NodeSchool.io exercises with assistance from a team of mentors.
NodeSchool.io is a series of choose-your-own-adventure style workshops that teach people how to use NodeJS, NPM, and other related tools by writing code to solve realistic problems. NodeSchool is entirely community driven and is 100% open source, which means you can take the exercises home and continue to learn!
We will have mentors available for the 'Learn You Node' workshop. This workshop is great for people who have never used NodeJS before or are just getting started. It begins with a basic "HELLO WORLD" exercise and then moves on to more advanced exercises dealing with synchronous & asynchronous I/O, filesystem
operations, TCP and HTTP networking, events and streams.
Why Agile? Because running full-scale Hadoop ML is very slow in development.
So instead you sample the data and move it to a local machine where you can explore it quickly with iPython Notebook/pandas/scikit-learn.
Later on, when you have model ready, you will do the full training run on the Hadoop but you will have to implement only one chosen algorithm.
Tutorial level: Intermediate
- Mac or Windows laptop
- Java 1.7. The necessary Scala and Gradle components can be downloaded off the Internet; we will provide them on Flash media as a backup
- Python distribution (we tested with http://repo.continuum.io/miniconda/Miniconda-3.4.2-MacOSX-x86_64.sh or http://repo.continuum.io/miniconda/Miniconda-3.4.2-Windows-x86.exe) and scikit-learn install (use `pip install scikit-learn`). As a backup, we will provide install on Flash media.
Bring your laptops and join us for an informative and hands on Node.js workshop with StrongLoop Dir of Products, Shubhra Kar.
In this workshop you'll learn:
- Jumpstart tips for Rails, .NET, Java and PHP developers new to Node
- Pros and cons of various frameworks for developing Node-powered APIs
- How to develop APIs from scratch with the open source Loopback.io framework
- Connecting Node apps to datasources including MongoDB, Oracle and MySQL
- Creating aggregations, mashups and custom methods on API endpoints
- Creating API-based mobile services like push and geolocation through iOS, JS and Android SDKs
- Enabling offline sync for your devices and apps
- Build and deployment best practices for Node
- How to monitor Node apps using StatsD and your own graphical visualization tool
- Managing logs in single server and multi-server configurations
- Deploying and managing Node clusters
This is a full-day tutorial in writing Android apps using the Eclipse IDE on Mac, PC, or Linux. An app is composed of objects written in Java, plus a screen layout in the Extensible Markup Language. See how the Java code manipulates the XML to present a user interface including buttons, sliders, and other controls. Draw text and graphics on the screen, respond to a touch or keystroke, recognize a swipe or a pinch, and perform simple animations.
We concentrate on three Android design patterns involving views, which are visible areas on the screen.
1. A listener is an object whose methods are called in response to a stimulus. We plug the listener into a view to make the view touch-sensitive.
2. A cursor is a source of data, possibly from a database. We plug the cursor into an adapter, which encases each item of data in a separate view.
3. An adapter view displays a series of views on the screen. We plug an adapter into the adapter view to provide the views to be displayed.
As our finale, we let a component of one app launch and communicate with a component of another app on the same device.
Tutorial level: Intermediate.
Prerequisites: Requires a reading knowledge of the Java language. The examples will be displayed and run on a Mac during the tutorial. If registrants would lke to run the examples on their own machine, they can bring a Mac, PC, or Linux equipped with Eclipse and the current Android Developer Tools (ADT) plugin.