Qconn

Tutorials

QCon SF 2014: 22 tutorial options

 

 

Tutorials for QCon San Francisco 2014 will take place on November 6th and 7th.

There will be half-day and full-day tutorials, with 22 tutorial options. The schedule is now complete.

 

 

Thursday November 6, 2014 Tutorials Day #1

Location: Bayview A Seacliff A Seacliff B Marina Room Bayview B Seacliff C Garden Room A
BOD - 12:00
12:00-12:55
14:00 - EOD
Java 8 

Adib Saikali  
[9:00 - 18:00]

 

Friday November 7, 2014 Tutorials Day #2

Day: Thursday
By: [Full Day]

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

Prerequisites:

Basic Unix command line knowledge

A laptop with a SSH client

Day: Thursday
By: Eric Evans [Full Day]

Build your awareness of the basic concepts and value of Domain-Driven Design (DDD) in one day. Understand what DDD is and when and why it is valuable to software intensive organizations. Overview the basic principles and processes needed develop the useful sort of models, tie them into implementation and business analysis, and place them within a viable, realistic strategy.

 

Target audience: Any person seriously involved in software development, including developers, technical leaders, analysts, development managers and non-technical business experts.

 

Prerequisites: Some experience with projects developing complex software systems. Familiarity with iterative development processes. Attendees don't need to bring their laptop.

Day: Thursday
By: Adib Saikali [Full Day]

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.

 

Outline:

  • 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

 

Level: Beginner
Prerequisites: You are comfortable programming in Java. Bring a laptop configured with the all the required software.

 

Setup instructions

  • 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:
Day: Thursday
By: Jafar Husain [Full Day]

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
simplifying asynchronous programming in Javascript.

 

In this tutorial you will learn how you can use the familiar Javascript Array methods
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.

Day: Thursday
By: Mark Meretzky [Full Day]

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.

 

Tutorial content: http://i5.nyu.edu/~mm64/swift/

Day: Thursday
By: Eric Conner [Half Day]

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.

 

Rough Outline

  • 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

Prerequisites:
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.

Day: Friday
By: Gil Tene [Full Day]

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.

Day: Friday
By: Peter Bloom [Half Day]

Git is today’s premier version control repository and an important collaboration tool for software development organizations because of it’s ease of use, facilitation of code review, and flexible branching model.

 

In this deep-dive workshop, we'll show you how to effectively use the most important Git functions in both the command line and RubyMine IDE. We’ll show you how to initialize, commit, branch, merge, and share repositories with others. We’ll look at the Github and Bitbucket cloud repo services; and examine web flow, pull requests, resolving code conflicts, and deployment systems. We’ll also discuss some best-practices for enterprise-level code teams.

 

This workshop will provide you with a solid understanding of why distributed version control systems are an essential part of any development effort, and equip you with skills to effectively apply Git to your everyday work.

Day: Friday
By: Hien Luu [Half Day]

Apache Spark is a new and exciting open source data processing engine and it is deemed as the next-generation successor of MapReduce. It was designed from the ground up to support streaming data processing as well as complex iterative algorithms. Apache Spark provides a nice abstraction of large sets with the concept of Resilient Distributed Datasets (RDD) and provides elegant APIs to easily manipulate these data sets.

 

This tutorial will introduce the core concepts in Apache Spark and will include hands on exercises for using RDD APIs to solve common data processing problems.

 

Here is what you can expect to learn from this tutorial:

 

  • Understand Apache Spark architecture, core concepts, programming model
  • Using Spark shells for interactive data analysis
  • Parallel programming with Spark RDD APIs
  • Developing standalone Spark applications
  • Understand Spark streaming
  •  

Target Audience: Architect and software engineers interested in big data processing

Day: Friday
By: Jafar Husain [Half Day]

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!

Day: Friday

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.

Day: Thursday
By: Amr Elssamadisy [Full Day]

If you are lucky, you have been on a “magic team” at least once in your career. Those teams leave a mark on us personally, and do great things for the organizations we work for. But teams and people are so complex that it almost seems that it is by pure chance that you find yourself on one of those teams. They are the right balance of technical expertise, ways of working together (like agile methods), and culture - that invisible thing that we all know is important but don’t know quite how to describe, let alone see and deliberately create.

 

The vast majority of talks and tutorials at QCon will allow you to advance the first two ingredients of high performance - technical excellence and process. In this tutorial you will EXPERIENCE the creation of a team culture that supports this level of performance in a team. After that, we’ll break it down into it’s component parts, and explain the theory behind it so you can deliberately create and modify your team cultures at work.

 

That’s a really high bar!

 

And to do this you will need to come in prepared to explore the human dynamics - the touchy-feely parts - of working together. Throughout the day we will have a team project to deliver. That project will be your vehicle to experiencing the deliberate creation of a team culture in accelerated format.

 

You’ll discover how safety - mental safety - is absolutely necessary for working together. You’ll learn about respect - and how the lack of it can tear a team apart and create an Us vs. Them divide. And you’ll experience the difference a mindset of ownership makes to our work and how to invite people to take ownership with you.

 

You may leave with new insights into how team cultures work and how they magnify and/or destroy our ability to produce results as a team no matter our technical skill or process of choice. Or, you may leave feeling that this was a total waste of time and, if anything, this touchy-feely stuff is a load of bull. Either way, you’ll experience a brand-new way of seeing our relationships and interactions with our teammates and their effects on ability to produce results.

 

High performance teams are rare. This workshop is here to help make them less rare and to give you the experience and information you need to create a culture that gives your team a chance at great results.

Day: Thursday
By: Daniel Buchner [Half Day]

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.

 

Tutorial level:
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.

Day: Thursday
By: Sasha Ovsankin [Half Day]

In this half-day tutorial we explore the hybrid approach to solving data analysis and machine learning problems: we will prepare and sample data on Hadoop using Scalding and then quickly analyze the sampled data on local computer using scikit-learn.

 

Scalding is a leading Scala DSL for Hadoop development. Scalding allows expressing data transformations as sequence of operations on collections and the resulting code is easy to understand, succinct and expressive.

 

Python is rapidly gaining popularity among Data practitioners and catching up with tools like MathLab and R. scikit-learn is The Machine Learning package for Python. Combined with python tools like iPython Notebooks and pandas, it allows amazingly convenient workflow for data analysis.

 

Combining Hadoop and local workflows for data analysis brings the best of both worlds: the sheer computational power of Hadoop with agility of local development with scikit-learn.

 

Tutorial level: Intermediate

Prerequisites:

Day: Thursday
By: Marty Weiner [Half Day]

Learn how to make a game in Unity3D that can be deployed to Android and iPhone devices. By the end of the session you will have written a playable 3d graphical adventure starring some cute dinosaurs, who live in a cute medieval village, but are now caught under a zombie spell, and only you can save them.

 

I will provide the initial models, levels, and basic logic components, and together we'll do the rest.

 

Tutorial level : Beginner to Intermediate. Some JavaScript experience is recommended, but if you don't know any, we can pair you with somebody.

 

Prerequisites: all you need is a (free) copy of Unity3D downloaded and installed:
http://unity3d.com/unity/download/
It's a large download, so please download now!
This works on Windows and Mac.

Day: Friday
By: Michael Nir [Full Day]

There is no right way, nor is there only one way to influence others. Everything, but everything, is a factor when influencing people. Your job requires you to influence people just about all of the time. It may take the form of gaining support, inspiring others, persuading other people to become your champions, engaging someone's imagination, creating relationships. Whatever form it takes, being an excellent influencer makes your job easier.

 

This one day training provides practical hands on experience of influence, primarily in a matrix organization; where informal power is the driver for success. We equip participants with relevant best practice tools for influencing without authority; Participants will be involved in recreating and re-running real interpersonal situations using the learning to discover specific behavior patterns, relate to them, investigate different approaches and learn how to conduct themselves in enabling objective based actions.

 

You’ll learn how to:

  • Identify stakeholders perspectives, and employ the appropriate communication and influencing style;
  • Exercise situational based influence through reading interpersonal cues and body language;
  • Practice the secrets of persuasion in getting others’ support;
  • Create PowerPoints, documents and Prezi, with the listeners’ preferences in mind;
  • Employ concepts of Gestalt and NLP in influencing;
  • Analyze your weak points and areas for personal improvement;
  • Convince the organizational bear by planning a tailored, systematic approach for gaining support, resources and collaboration from individuals in organizations where you have little or no formal influence.
  •  

    Prerequisites:An open mind, willing to learn the secrets of influence.

     

    Who Should Attend - Among those who would benefit from this workshop are:

    • Engineers and developer, architects and system analysts, required to persuade others in teams and in business;
    • Scrum masters and teams looking to further their ideas in a collaborative environment;
    • Project, Program and portfolio managers who need to gain support from business and development;
    • Generally – those wishing to learn how to perform their job better by enlisting the support of others.
    •  

    It is about learning new skills and honing existing ones.

Day: Friday
By: Franklin Webber [Half Day]

With Chef, you can automate how you build, deploy, and manage your infrastructure. Your infrastructure becomes as versionable, testable, and repeatable as application code. More importantly, Chef makes it more delightful.

 

This interactive session teaches through a series of coding challenges. Each challenge introduces you to the tools, terms, and philosophy of Chef as you deploy a small web application.

 

  • Understand the awesomeness of convergence infrastructure
  • Learn how to easily and repeatably install software
  • Feel the relief that comes from using delightful automation

 

Tutorial level: Beginner

Prerequisites:

A laptop with an SSH client

Basic Unix command line knowledge

A text editor you're passionate about

Day: Friday
By: Pete Soderling [Half Day]

Arguably the most important skill an engineering manager can learn right now is how to attract, hire and retain the best developers possible.

 

The best managers understand that people are their most valuable asset. The paradox is they rarely have put in the work in developing their own hiring process to consistently enable them to identify and attract the best talent.

 

This workshop will teach you a process for engineering hiring compiled from best-practices at top companies. We will address the entire technical recruiting process and will teach you tips and tricks that will enable you to get better and more efficient at each stage of your hiring.

 

Some of the topics we will cover include:

  • Understanding the hiring funnel
  • Fixing your broken job specs
  • Marketing that makes a difference
  • Using & misusing recruiters
  • Effective technical interviewing
  • Establishing a scalable process
  • Social media hacks that actually work

 

You’ll leave this tutorial will your head full of practical insights and steps you can immediately take to improve your company's hiring process as well as the inspiration to implement them effectively.

Day: Friday
By: Tim Ottinger [Half Day]

How can we infuse quality not only in our products, but embed it into the DNA of the organization?

 

Software development is an inherently human, complex, busy system. Every software process is a flow that is subject to turbulence (such as queuing and blockages).

 

Most organizational cultures hide, tolerate, and sustain many hazards and risks that exacerbate the problems inherent in a system where everyone must think clearly and make good decisions every day.

 

We have learned important lessons from sources as diverse as manufacturing, eXtreme Programming, the Lean Startup movement, sports coaching, and Positive Psychology.

 

We can do better. Discover how to unlock the potential of your team by protecting them from technical, social, cultural, and interpersonal risks.

Day: Friday
By: Ross Kukulinski , Tony Pujals [Half Day]

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.

 

Tutorial level: Beginner/Intermediate. This tutorial is geared towards people with little to no NodeJS or Javascript experience, but having some programming background will be helpful. Attendees should bring a laptop (Linux, Windows, or Mac) pre-installed with NodeJS and NPM (visit http://nodejs.org/) as well as a text-editor of choice.

Day: Friday
By: Shubhra Kar [Half Day]

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

 

To get the most out of the workshop, attendees should have at least a basic understanding of how Node works in theory, basic JavaScript skills and a current stable version on Node installed.

Day: Friday
By: Mark Meretzky [Full Day]

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

 

Tutorial content: http://i5.nyu.edu/~mm64/android/