Tutorials
This session takes the familiar technical Gang of Four pattern format but applies it to presentations using tools like Powerpoint and Keynote.
Patterns are like the lower-level steps found inside recipes; they are the techniques you must master to be considered a master chef or master presenter. You can use the patterns in this session to construct your own recipes for different contexts, such as business meetings, technical demonstrations, scientific expositions and keynotes, just to name a few.
This session shows lots of patterns and antipatterns, things you should avoid doing in presentations. Each pattern is introduced with a memorable name, a definition, and a brief explanation of motivation. Attendees learn where the pattern applies, the consequences of applying it, and how to apply it. The authors also identify critical antipatterns: clichés, fallacies, and design mistakes that cause presentations to disappoint. These problems are easy to avoid – once you know how.
In this half day workshop we will get some practical hands on experience with redis - one of the most popular key-value NoSQL data stores and MongoDB - the most popular document database. We'll look at use cases, installation, data modeling and how to select between and work with these versatile, powerful data stores.
Pre-requisites:
Experience with building database backed applications is the only requirement for this class. You'll also get the most from the class if you bring a laptop with a power cord (or plenty of battery life) to follow along with some basic exercises, although you could do the class without a computer. You'll get a little more out of the class if you have a Mac or Linux laptop as we will be installing both of the data stores and the installers for redis on windows are a PiTA, so we'll mention windows installs but if you really want to get the most from that part of the class, either use a Mac/Linux laptop (or VM) or pre-install redis using the instructions at https://github.com/MSOpenTech/redis or https://github.com/dmajkic/redis/. Irrespective of your OS, please also pre-install a recent copy of MongoDB by following the instructions here: http://docs.mongodb.org/manual/installation/ - we'll run through this quickly in class to explain options, but you'll want to have the installation done before you get to the conference venue.
Outline
Hello redis
- Introducing redis
- Common comparisons
- Installing redis
- Key data types
- Use cases
- Deployment tips and tricks
- Resources
Hello Mongo
- Introducing Mongo
- Common comparisons
- Installing Mongo
- Data modeling in MongoDB
- Use cases
- Deployment tips and tricks
- Resources
In this half day workshop we'll look at the use cases for graph databases, and we'll install neo4j, the most broadly adopted graph database available. We will also look at data modeling with graph databases and we'll get some hands on experience with the declarative "cypher" query language - think "SQL for graphs".
Pre-requisites The only background for this workshop is some programming experience. You will get much more out of the workshop if you bring a laptop and either a power brick or enough battery power to run your laptop for the three hours.
Outline
- An introduction to graphs
- Installing Neo4j
- An introduction to cypher
- Data modeling for graphs
- Use cases for Neo4j
As evidenced by the inclusion of lambdas a wide array of programming languages such as PHP, Mathematica, JavaScript, Java 8, Scala, Clojure, C#, Visual Basic, Objective-C, ... functional languages represent the leading edge of programming language design. In particular the pure and lazy functional language Haskell provides Petri dish-like setting in which new programming concepts are introduced and studied.
In this tutorial we will build upon the highly popular Channel 9 Functional Programming Lectures (http://www.cs.nott.ac.uk/~gmh/book.html) and focus on a number of more advanced topics in fundamentalist functional programming such as cata-, ana-, hylo- and other morphisms, monads, thinking with types, juggling with code, and show how these skills can be applied in making you a better hacker no matter what language you use in your day job.
In this half-day workshop we will explore some tools and techniques for debugging JavaScript applications. The focus will be on front-end JavaScript, but many of the lessons learned will apply to back-end JavaScript as well. Using the Firefox Developer Tools as a starting point you will see how to inspect your code for correctness, measure its performance characteristics and understand its runtime behavior.
You will get insights into how profilers work, when to use them and when not to. You will learn how to debug other languages that compile to JavaScript, like CoffeeScript, using source maps and how to avoid digging into framework implementations just to figure out how your own code behaves. We will also see how mobile web apps can be debugged locally or remotely and how you can take matters into your own hands by extending the Firefox Developer Tools to tailor them to your needs.
This tutorial is sold-out.
In this hands-on tutorial you will learn DevOps principles and practices, and how to use Vagrant, Puppet, Nagios, Git and Go to automate the configuration, management and monitoring of the infrastructure needed to support a modern web application. By the end of the tutorial you will be comfortable with the tools, and have a playbook of patterns and pro-tips for managing your infrastructure in a fully automated fashion.
Prerequisites: you’ll need a laptop with at least 4Gb RAM and Vagrant 1.1.x, VirtualBox, and your favourite text editor installed. 8Gb RAM and an SSD is strongly recommended.
On Day 1, we start by installing our example application (opencart) and its dependencies manually on VMs we’ll create using Vagrant. We’ll then set up Nagios and show how to monitor infrastructure and applications with Nagios, and discuss monitor-driven development. Next up is a brief tour of Puppet. We’ll end the day by demonstrating Vagrant’s Puppet integration and using it to set up our database box.
On the second day we’ll have you get your web and monitoring hosts up using Puppet, and guide you through a series of refactorings that show off well-formed Puppet. We’ll then go through how to do TDD of your infrastructure with cucumber-nagios. In the final part of the tutorial we’ll show how to create a deployment pipeline for infrastructure changes using Git and Go. If we have time, we’ll show how to use Vagrant’s AWS integration to drive Amazon EC2.
Based on the upcoming O'Reilly book "RESTful Web APIs" by Leonard Richardson and Mike Amundsen, this workshop covers the basics of Fielding's REST style, HTTP standards, and common practices for APIs for Web. Key topics such as how how use hypermedia to increase API flexibility and how application profiles can improve API interoperability are also covered. In addition, a wide range of existing message formats and semantic vocabularies are reviewed along with a procedure for selecting and applying these existing standards to your own implementations.
Other subjects will be covered such as caching, versioning, and supporting RESTful APIs on protocols other an HTTP.Throughout the workshop, attendees will be able to apply step-by-step guidance on how to create their own RESTful Web API and share these designs with the group at the end of the session.
We aspire to make great software. But too often we come up short.
After years of experiencing our own failures and successes and studying those of others, we have come to believe that making great software depends less on tools and techniques, and more on working together effectively to solve difficult problems.
How well we work together is governed by the agreements we make and the quality of the relationships we form as a result of how we manage those agreements. All too often, however, we manage agreements poorly. We break our agreements, and when we do, we fail to confront and renegotiate them quickly and effectively.
When these things happen, the trust we share in ourselves and in our colleagues erodes, and we unintentionally reinforce a culture that reduces our ability to solve the problems we face every day.
The best teams and organizations—those that achieve the highest performance and take the greatest joy in their work—have a discipline around “how we work together”. We see this discipline as the agreements they make and the workplace culture that results from making and managing agreements well.
Agreements, well made and well managed, are the engine of culture change. This culture engine, when properly maintained and fueled, creates an environment that amplifies the power of the tools and techniques we use and supports the extraordinary collaboration that is required to achieve extraordinary results.
By mastering agreements, we realize the full potential of ourselves and of our teams to solve the wonderful and terrible problems we encounter when we aspire to make great software.
Candidates in this workshop will be introduced to a completely new way of thinking about concurrent programming. By taking a hardware up, rather than theory down, approach you'll learn how modern x86 hardware operates and how when you show sympathy for this hardware your algorithms will absolutely scream. In addition to learning the basic techniques of building high-performance data structures, a performance testing and profiling discipline will be introduced that is fundamental to working at the extremes of systems performance.
Understanding Mechanical Sympathy
- Performance considerations on modern hardware
- How modern x86-64 hardware informs concurrent and high performance programming techniques
- Memory models for software and hardware Why contention of any type is the enemy and how to avoid it
- How we manage contention when we absolutely must How the JVM provides support for concurrent programs
- Profiling and performance testing
Concurrent and High-performance
- Algorithm Design Lock-free concurrency primitives
- Signalling state change
- Ensuring order
- Concurrent data structures
Candidate Requirements
- Experience of the Java Programming Language.
- A laptop capable of running 4 concurrent threads - This can be a dual core with hyperthreading enabled
- Java 5+, and Ant 1.8+ installed, plus IDE of your choice
- More advanced profiling techniques can be demonstrated if running Linux
This is a full-day tutorial in writing iOS apps using the Xcode IDE on Macintosh. An iPhone or iPad app is made of intercommunicating objects. Learn to create and destroy the objects and send them messages in the language Objective-C. Use them to draw text and graphics on the screen, respond to a touch or keystroke, perform simple animations, and display controls such as buttons and sliders. We concentrate on three iOS design patterns. (1) A control object can call a method of its "target" object in response to a touch. (2) 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. (3) A "view controller" can manage the view object underneath it, and forms the connection between the view and the other objects in the app.
Whether or not you like javascript, node.js is becoming an serious contender for building highly interactive web applications. In three hours we'll look at the good, the bad and the ugly of programming in node, we'll review the nom ecosystem and we'll build a simple app and get it running to experience working with node directly.
Prerequisites: this is a hands on workshop, so you'll need to bring a laptop and either a power brick or enough battery power to run your laptop for the three hours. To save venue wifi, I'd also recommend installing node.js from here using the "install" button: http://nodejs.org/
Outline
- What is node.js?
- Why node?
- Building a simple app
- NPM
- Building a simple app using express
To process big data and build big data products at rapid pace requires highly productive data processing technologies. Apache Pig and Apache Hive are designed to allow data scientists, data analysts, and engineers to be highly productive and to iterate quickly when performing data processing at massive scale.
This tutorial will not only provide hands-on experience working with Apache Pig and Apache Hive, but will also provide a glimpse at how they are used at LinkedIn to build big data products. Here is what you can expect to learn in this tutorial:
- Quick high level overview of Hadoop data processing framework
- Understanding how Apache Pig & Apache Hive fit into Hadoop data processing ecosystem
- Overview of Apache Pig architecture and data flow language
- Overview of Apache Hive architecture and query language
- Demonstration of writing and running Apache Pig scripts
- Demonstration of writing and running Apache Hive queries
- Discussion about the strengths and weaknesses of Apache Pig and Apache Hive and when to use which
- Glimpse of upcoming query processing technologies & productivity tools like Netflix Lipstick
Target Audience:
- Architects and engineers that have an interest in big data topics
- Participants should have some high level knowledge of Hadoop
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 dive deeply into two common areas of concern for application responsiveness in Java environments: Garbage Collection & Application Response Time Characterization. The workshop will cover these two areas in depth.
We will start with a detailed discussion of Garbage Collection mechanisms: Garbage Collection is an integral part of application behavior on Java platforms, and is often dominantly responsible for application responsiveness behavior. As such, it is critically important for Java developers and application managers to understand the basic workings of garbage collectors so that they can better gauge both as application architecture choices and the actions they can take in selecting and tuning collector mechanisms. Gil will review and classify the various garbage collectors and collection techniques available in JVMs today, and provide an overview of common garbage collection techniques including generational, parallel, stop-the-world, incremental, concurrent and mostly-concurrent algorithms. We will define terms and metrics common to all collectors, and classify each major JVM collector's mechanisms and characteristics and discuss the tradeoffs involved in balancing requirements for responsiveness, throughput, space, and available memory across varying scale levels. We will include an interactive discussion of how these tradeoffs play off in the real world, and discuss ways to minimize or completely eliminate application responsiveness impacts from Garbage Collection.
We will continue with a detailed discussion of Application Responsiveness Characterization: Understanding application responsiveness and latency is critical for delivering good application behavior. Gil will start with a discussion 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, 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.
Machine learning makes human decisions and insights scalable. Simple applications of a few basic techniques can dramatically improve productivity and simplify rote tasks throughout your organization. This tutorial will focus on Vowpal Wabbit, a widely-used classification and regression package. You'll learn how to identify problems where basic ml tools can automate repetitive tasks, what kind of data you'll need to ensure success, and how to evaluate and report on performance. You'll also learn how to integrate insights from across your organization into machine-learning systems, and how tools like Vowpal Wabbit make solving fuzzy problems fun.
The tutorial will start with a walkthrough of how we aggregate and use data in the war on abusive content at Pinterest, and an overview of some of the systems we've built along the way. You'll then learn how Vowpal Wabbit implements machine learning techniques, and how to map your problems to regression and classification problems. You'll use VW to train a model on a sample dataset and learn how to evaluate and optimize the performance of this model. Finally, you'll learn how to monitor the models you've built, and how to integrate these models into production systems.
What's 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 talk 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
In this talk we'll be exploring the Reactive Extensions (Rx) library (https://rx.codeplex.com/) which allows us to treat events as collections. You'll learn patterns you can use on both the client and the server, allowing you to build end-to-end reactive systems.
This tutorial is sold-out.
In this hands-on tutorial you will learn DevOps principles and practices, and how to use Vagrant, Puppet, Nagios, Git and Go to automate the configuration, management and monitoring of the infrastructure needed to support a modern web application. By the end of the tutorial you will be comfortable with the tools, and have a playbook of patterns and pro-tips for managing your infrastructure in a fully automated fashion.
Prerequisites: you’ll need a laptop with at least 4Gb RAM and Vagrant 1.1.x, VirtualBox, and your favourite text editor installed. 8Gb RAM and an SSD is strongly recommended.
On Day 1, we start by installing our example application (opencart) and its dependencies manually on VMs we’ll create using Vagrant. We’ll then set up Nagios and show how to monitor infrastructure and applications with Nagios, and discuss monitor-driven development. Next up is a brief tour of Puppet. We’ll end the day by demonstrating Vagrant’s Puppet integration and using it to set up our database box.
On the second day we’ll have you get your web and monitoring hosts up using Puppet, and guide you through a series of refactorings that show off well-formed Puppet. We’ll then go through how to do TDD of your infrastructure with cucumber-nagios. In the final part of the tutorial we’ll show how to create a deployment pipeline for infrastructure changes using Git and Go. If we have time, we’ll show how to use Vagrant’s AWS integration to drive Amazon EC2.
This is a full-day tutorial in writing Android apps using the Eclipse IDE on Mac, PC, or Linux. An app is made of two parts: a screen layout written in XML (the Extensible Markup Language) and objects written in Java. Learn how these two halves of the app interact with each other. Draw text and graphics on the screen, respond to a touch or keystroke, and display controls such as buttons and sliders. An app can be divided into components called "activities", and an activity in one app can launch and communicate with an activity in another app on the same device.
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 various stimuli. We plug a listener into a view to make the view touch-sensitive. (2) A "cursor" is a source of data. We plug a 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 an adapter view to provide the series of views to be displayed.
Love it or hate it, with richer client frameworks like backbone, spine and knockout and with server side frameworks like node.js, if you are a professional web developer, you are probably going to find yourself writing some Javascript in the future. It's also an interesting language. It has been described as a love child between Scheme and Java, it has prototypical rather than classical inheritance (thank you Self), and it has some really nice functional programming capabilities (along with some really horrible design decisions).
In three hours we're going to do a whirlwind, hands on tour of the language, teaching you the skills required to become a competent Javascript developer. We'll also briefly touch on Javascript testing using Jasmine and give a sneak peak into Coffeescript - a thin layer over javascript which reduces the syntactic noise, fixes some of the worst design decisions and even adds classes.
Prerequisites: This is a hands on workshop, so you'll need to bring a laptop and either a power brick or enough battery power to run your laptop for the three hours. Also, I'll be using google chrome, so you might find it easier to follow along if you have that installed.
Outline
- Background
- Language
- Testing
- Frameworks
- Coffeescript
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.