Unleashed Innovation: The Quicken Loans Bullet Time Experiment – Bill Parker

ROOM W2-69  1:10 pm to 2:10 pm

In today’s world of information overload and visibility into every nook and cranny of your operation it’s tempting to relentlessly measure, tinker, and push for greater efficiency. This model has served us well in the past but survival today requires innovation and there is no pragmatic model for creativity. You have to let go of the wheel and set your folks free.

For the first time ever Bill Parker the creator of Quicken Loans Bullet Time will discuss the details of their innovation program, what works, what doesn’t, and highlight some of the products it has produced.

GM Sponsor Presentation – Prabodh Deshmukh and Vani Yalamanchili

ROOM W2-66  1:10 pm to 2:10 pm

Prabodh Deshmukh and Vani Yalamanchili from GM will provide a overview of the industry leading IT Transformation currently underway at GM with details regarding the architecture, design patterns, technologies, and platforms being used for traditional and mobile applications.

Cudafy Me – Graphics Processor Programming in C# on Windows 8 – John Hauck

ROOM W2-61   11:10 pm to 12:10 pm

The ThreadPool is fine for little dips, but this is the year to dive head first into the GPGPU – the General Purpose Graphics Processing Unit. In this talk we will be solving the traveling salesman problem by brute force. That is, we will compute the length of every possible route connecting a series of cities – to find the shortest one. We will do this entirely in Visual Studio C# using three techniques: single-threaded CPU, multi-threaded CPU, and the massively parallel GPGPU. We will spend most of the time learning how to use NVidia’s CUDA with HybridDSP’s Cudafy. After attending this talk you will see the universe as a massively parallel phenomenon that is ripe for you to model it.

git gone wild: how to recover from common git mistakes – Magnus Stahre

ROOM W2-66  10:00 am to 11:00 am

“Oh no! I just typed something into git and now my work is gone! Ahh!”
Don’t panic. Contrary to popular belief, git is one of the most non-destructive version control systems available. When used right, git
never loses any data, and even when misused, chances are very high you can still recover.
This talk will present turn-by-turn directions on how to recover from a wide array of common git mistakes, and also provide some workflows
to minimize them.

Garbage Collection In Depth – Ken Fox

ROOM W2-61  2:15 pm to 3:15 pm

Ken will be surveying key garbage collection algorithms. He’ll be showing how they work, comparing their strengths and weaknesses, and even getting into practical applications unrelated to language implementation.

Software Challenges and Innovation in a Mission Critical Public Safety Solution – Tim Morehouse and Duane Kietzman

ROOM W2-63   11:10 pm to 12:10 pm

Public Safety software is integral to maximizing the efficiency of police and firefighters in saving lives.  New World Systems has changed the landscape of software development in this space by leveraging leading edge technology for Enterprise Computer-Aided Dispatch (CAD) and Mobile computing.  Come get a quick, first-hand view of what really occurs during a 911 emergency from the viewpoints of 911 Dispatchers and Police Officers as units are mobilized and managed to the scene.   Then, we’ll discuss the unique technical challenges faced and how we’ve been using concepts for years that are now becoming common in emerging software packages, such as Massively Multiplayer Online Video Games and modern Mobile Computing Solutions.

Going Mobile with Windows Azure Mobile Services – Chris Risner

ROOM W2-70   2:15 pm to 3:15 pm

When you start building the next great mobile app, do you want to worry about your backend? Do you want to figure out hosting and support servers, or just work on your killer app? Windows Azure Mobile Services allows you to do that. In this session we’ll cover how you can connect iOS and Android applications to a reliable cloud based backend that gives you super easy data storage, user authentication, and push notifications with just a few clicks. You will leave knowing how to get your backend setup so you can store your apps data and more so you can start building apps immediately.

Getting turned on with Arduino – Terry May

 ROOM W2- 68   10:00 am to 11:00 am

Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.

Terry May recently began hacking with Arduino and will share his findings and the possibilities of the Arduino world with his usual fun, down-to-earth, curious and un-pretentious flair.

Asynchronous to Realtime web programming for JVM – Nilanjan Raychaudhuri

ROOM W2-69  11:10 pm to 12:10 pm

Waiting is over. Welcome to the world of asynchronous web programming on JVM

Why non blocking web programming is important? Because every time you wait for something to happen a kitten dies. Seriously because it will help your web application to handle more request with the resources you have already. Non blocking techniques are already used by high traffic websites like facebook and linkedin. But you don’t have to be facebook or linkedin to take the benefits non blocking web programming. In this presentation I will explain the theory behind the non blocking (also known as asynchronously) web programming and the tools available to you to build scalable web applications in JVM.

Concurrency in iOS – Jeff Kelley

ROOM W2-68  3:25 pm to 4:25 pm

iOS includes Apple’s new Grand Central Dispatch framework for managing concurrency. Since Grand Central Dispatch makes heavy use of blocks, Apple’s closure-like extension to the C language, this talk will first cover blocks, then go into Grand Central Dispatch. We’ll discuss usage and best practices from the ground up for GCD, allowing you to write awesome, performant apps. As an added benefit, sinceGCD is a system-level framework, everything in this talk applies equally to Mac OS X and iOS!

Continuous Integration in the Mobile World – Godfrey Nolan

ROOM W2-70  1:10 pm to 2:10 pm

Just because you’re coding Mobile applications doesn’t mean that you can’t take advantage of the benefits Continuous Integration (CI). Come to this session and learn all about CI on both the iPhone and Android platforms. Learn the difference between Hudson and Jenkins, all about headless emulators, as well as the best tools to use for unit testing, functional testing and beta app deployment of your mobile apps.

Design Patterns and Backbone in JavaScript – Aaron Maturen

ROOM W2-66  11:10 pm to 12:10 pm

For the presentation I will create a monster themed Web Application using MV* architecture and Backbone.js through the presentation and application I will explain how JavaScript benefits from Design Patterns to prevent ‘monstrous code’.

An alarming amount of web developers have adopted JavaScript by tying their data directly to the DOM. When web applications use a lot of javascript, this becomes a hinderance and prevents efficient, maintainable javascript. It becomes a monstrous task keeping the data in sync between the HTML UI, the Javascript Logic, and the database model. For rich client-side applications developers can utilize the same design patterns that they’ve used for years to make their applications more structured and maintainable. Through Design Patterns developers force their applications to become more modular, containing a set of highly decoupled, distinct pieces of functionality. 

The two main Design Patterns that my presentation will focus on are PubSub and MV*. 


Effective Code Quality through Behavior-Driven Development (BDD) – Murali Mogalayapalli

ROOM W2-61  10:00 pm to 11:00 pm

Extreme Programming originally had the rule to “test everything that could possibly break”. This practice has evolved into what is known as Test Driven Development (TDD). But TDD tooling still forces developers to think in terms of tests and assertions instead of specifications, requirements, and end-user value.

Behavior Driven Development (BDD) changes the game by shifting the focus to usage interactions of software.  BDD was developed by the Dan North as a response to the issues encountered in teaching Test DrivenDevelopment.  It combines using native language with the ubiquitous language of Domain Driven Design to describe the purpose and capability of the code being written.  This separation of concerns allows the domain experts to define the expected behavior of the system which is translated into test cases even before the software itself is written.   The use of a language close to the human language increases the early and often collaboration between the Business Analyst and the Developers.

This session covers the concepts and value of adopting BDD and Integration testing into your softwaredevelopment practice and the frameworks available (JBehave, Cucumber, SpecFlow).  It then jumps into demonstrating the testing framework in action with practical examples of usage.

Functional Javascript – Joshua Kalis

ROOM W2-69  2:15 pm to 3:15 pm

The focus of this talk is to explore functional programming paradigms and how they can be applied in Javascript. Functional programming paradigms can help us: write smaller units of code which will enable more thorough unit testing – so that code breaks less often – and reuse those smaller blocks of code in more ways – so that we need to write less code. Slides will present some core concepts to functional programming, their definition and application in Javascript, followed by actual code refactoring.

Functional Principles for OO Development – Jessica Kerr

ROOM W2-63  10:00 am to 11:00 am

How is an expert OO developer to improve on his craft? By learning from other paradigms! Six principles of the functional style can apply to OO. Some of these principles are part of good practice already; some express patterns both old and new; all give us different ways of thinking about problems. For developers with no expertise in functional programming, examples in C#, Java, F# and Scala show new techniques for writing clear, quality code.

Graph Traversals in Neo4j with Gremlin Java – Bobby Norton

ROOM W2-63  2:15 pm to 3:15 pm

Graph databases are a NoSQL / polyglot persistence solution that provide a natural way to model and compute on complex, interrelated data. We’ll use Gremlin’s Groovy and Java dialects to see traversals in action on a network data set in Neo4j and Titan, a distributed graph database optimized for Big Graph Data.

Iconoclasm – Keynote – Ted Neward

ROOM W2-60  9:00 am to 9:50 am

History is littered with the stories of iconoclasts–people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes–and their successes and failures. From the baseball management vision of Branch Hickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly. For an industry that seems so ripe and so rife with “special personalities”, it would seem that programming is tied up deeply with iconoclasm. But what defines the iconoclast, what demarcates the “true” iconoclast from the mere pretender, and how can we use the characteristics of the iconoclast to change our own immediate surroundings for the better?

Intro to iOS Development – Brian Munzenberger

ROOM W2-70  11:10 am to 12:10 am

Development for mobile platforms has gotten easier as the languages and tools have matured.  In this presentation, Brian will introduce development for iOS and demonstrate how easy it can be by building a simple application from scratch using the native tools freely available from Apple.  This hour will include:
  • An introduction to Xcode and the iOS Simulator
  • Building user interfaces and transitions using Storyboards
  • Using the Cocoa Touch Model View Controller framework
  • Loading data into model objects and passing it between views
  • A discussion of performance considerations when developing for a mobile platform

Is a Mobile-Friendly Website Enough? – Jeff McWherter

ROOM W2-67  10:00 am to 11:00 am

Do I Really Need a Mobile App, or is a Mobile-Friendly Website Enough?
Mobile apps are the hottest trend in tech right now, leaving many companies struggling to create a mobile strategy for their products or services. When defining this strategy, the question of “do I really need a mobile app” is the first barrier to be cross. Learn more about how to explain to a company why they truly need a custom mobile application, and when updating a portion of an existing web site, using responsive techniques, to be mobile device-friendly may be the more appropriate solution. (For any audience, recommended as a keynote presentation.)

It’s Just a Web Site: How Poor Web Programming is Ruining Information Security – Mark Stanislav

ROOM W2-66  2:15 pm to 3:15 pm

A review of recent web site attacks will be given to help understand what major vulnerabilities are common for web sites, how attacks are executed, and what a compromise can mean to a company, government, or other organization. Further attention will be given to: how an entity can prevent poor programming from ruining their security; how web programmerscompare to other industries for qualifications required to interact with highly sensitive data; and a forward-thinking discussion on how the industry can be proactive when hiring programmers. The goal of this presentation is to make all parties involved in information security aware of just how serious one poorly created web site can be to fabric of theirinformation security architecture and practices.

Java on the mainframe – More than what you think! – Walter Falby

ROOM W2-67  1:10 am to 2:10 am

In this presentation I’ll describe the mainframe environments in which Java runs, giving some background on one that is unique to z/OS. I’ll then outline how to develop and execute Java programs on z/OS. I’ll demonstrate, showing lots of code, how to connect Java to traditional mainframe programs. That’s the hard part! I’ll follow-up with some interesting Java and z/OS factoids. The mainframe operating system has many components and we will encounter a number of them during this presentation. I’ll provide a high-level description of those components and of z/OS itself. By the end of the session, you’ll have some appreciation for z/OS. And, just maybe, you’ll consider z/OS as a target platform for your own Java applications.

Magic Bullet, Thy Name Is Responsive Design – Marc Nischan

ROOM W2-68  1:10 pm to 2:10 pm

The session will cover a brief history of responsive design (it actually goes back a ways), Responsive Design vs. Adaptive Design, why you might or might not need a separate mobile site, “Mobile First” design philosophy and how that integrates with a successful responsive website, pitfalls of designing a responsive site, load time optimization and how that might affect your choice of javaScript libraries and CSS3 bits, how IE8 fits in to all of this, and  then some “check this out” stuff with links to sites.

MapReduce and Its Discontents – Dean Wampler

ROOM W2-63  3:25 pm to 4:25 pm

Apache Hadoop is the current darling of the “Big Data” world. At its core is the MapReduce computing model for decomposing large data-analysis jobs into smaller tasks and distributing those tasks around a cluster. MapReduce itself was pioneered at Google for indexing the Web and other computations over massive data sets.

I’ll describe MapReduce and discuss its strengths, such as cost-effective scalability, as well as its weaknesses, such as the latencies that limit its usefulness for real-time event stream processing and the relative difficulty of writing MapReduce programs. I’ll briefly show you how higher-level languages ease the development burden and provide useful abstractions for the developer.

Then I’ll discuss emerging alternatives, such as Google’s Pregel system for graph processing and event stream processing systems like Storm. I’ll emphasize whyfunctional programming is so important for big data applications. Finally, I’ll speculate about the future of Big Data technology.

Oh NODE you didn’t! – Calvin Bushor

ROOM W2-70  3:25 pm to 4:25 pm

Let’s walk through building an application using Node. I will demonstrate building a Node.js application and dive into some of the key components that allow Node to be event-driven and non-blocking by leveraging Socket I/O and Node’s EventEmitter.

Node is designed for writing highly scalable Internet applications, notably web servers. Programs are written in JavaScript, using event-driven, asynchronous I/O to minimize overhead and maximize scalability.

OpenGL – Bob Kuehne

ROOM W2-66  3:25 pm to 4:25 pm

OpenGL is a standard specification defining a cross-language, multi-platform API for writing applications and simulating physics, that produce 2D and 3D computer graphics. The interface consists of over 250 different function calls which can be used to draw complex three-dimensional scenes from simple primitives.

We will cover the need to know features of OpenGL ES 2.x, the standard for 3D graphics and the upcoming standard for WebGL, bringing 3D to desktop browsers. Attendees will come away with an understanding of what is needed to develop 3D apps for OpenGL ES.

Regular expressions – now you have two problems – Brian Friesen

ROOM W2-68  11:10 am to 12:10 am

Be afraid. Be very afraid. For you are about to enter the mysterious and forboding land of regular expressions. A land of strange-looking hieroglyphics. A land with many flavors. A land where its devotees possess seemingly magical powers over text. But be afraid no more, for you have a guide. And your guide will show you the way through this land.

In this session, you’ll learn the basics of how a regular expression engine works. Combining this knowledge with the dozen or so regex operations, you’ll be able to craft your own regular expressions with confidence. Perhaps more importantly, you’ll be able to decipher exactly what an existing regular expression does. In the end, you’ll probably discover that regular expressions are not as scary as you once thought.

Reverse Engineering .NET and Java – Joe Kuemerle

ROOM W2-70  10:00 am to 11:00 am

Learn the various techniques bad guys can use to extract information from your .NET or Java applications or at least how you can recover the source code that your predecessor deleted before he quit. A demo filled session on how easy it is to extract information from virtually any .NET or Java application.

Rise of the Web App – Kevin Dangoor

ROOM W2-69  10:00 am to 11:00 am

The web started as a platform for documentation and gained a good deal of interactivity during the last decade. Now, the web is moving forward as an application platform in ways that no one would have predicted a few years ago. I’ll talk about some of the technology, tools and services that are raising the web up to the next level. Web standards like media queries, appcache, IndexedDB and WebGL provide capabilities for a new set of applications, and Mozilla’s WebAPI project enables an entire phone to be built of the web (FIrefox OS/Boot2Gecko).

Scala: Objects and Methods and Functions, Oh My! – Dianne Marsh


Self Engineering – Keynote – Chad Fowler

ROOM W2-60 4:30 pm to 5:30 pm

How do you apply engineering discipline to the thing that matters most: yourself? We’re software engineers or systems engineers or network engineers. We have learned lessons the hard way. These lessons boil down to immutable laws; some things work and some things don’t.
Successful engineers apply these hard-won lessons to their professions. We use the same techniques day in and day out to create systems to make other people’s lives better. But few of us apply the same kind of systems thinking to our own lives, careers, jobs, or organizations.
Let’s start thinking of our daily lives and work as a system, just like a system we would create or maintain in our professions. How would you approach your life differently if it were a system you were creating for a client? How do you define success? How do you measure it? How do internal and external quality differ?

Testing with Spock – Elizabeth Henderson

ROOM W2-67  3:25 pm to 4:25 pm

Spock is a testing and specification framework for Java and Groovy applications. What makes it stand out from the crowd is its beautiful and highly expressive specification language. Thanks to its JUnit runner, Spock is compatible with most IDEs, build tools, and continuous integration servers. Spock is inspired from JUnit, jMock, RSpec, Groovy, Scala, Vulcans, and other fascinating life forms.

The class that knew too much: refactoring spaghetti code – Matt Groves

ROOM W2-68  2:15 pm to 3:15 pm

The Single Responsibility Principle states that a class should have one (and only one) reason to change. Classes that don’t adhere to this principle can result in tightly coupled spaghetti code that leads to more bugs and higher maintenance. We’ll look at how to identify these classes, and how to clean them up using refactoring tools, design patterns, and even aspect-oriented programming.

The State of F#- Why You Should (or Shouldn’t) Care – Chris Marinos

ROOM W2-67  2:15 pm to 3:15 pm

In this talk, we’ll discuss the past, present, and future of F# programming. You’ll learn about the latest F# innovations like Type Providers, but more importantly, you’ll gain an understanding of how F#’s unique features can help you solve problems for your clients. You’ll also learn about some situations that are not a great fit for F#, and how to avoid them. We’ll wrap up with a discussion about the future of F#. By the end of this talk, you should have a good idea of what F# brings to the table, and how you do (or don’t) want to use it in your organization.

Using types to write your code for you – Job Vranish

ROOM W2-61  3:25 pm to 4:25 pm

In languages with type inference (Haskell, Scala, F#), the type system can be an invaluable tool that not only can prevent silly errors but can actually make algorithm development easier. In fact, if you’re careful with how you construct your types you can practically make the types write the code for you! In this talk I’ll show how moving some information about the structures in your code into the type system can convert some of the hard work of algorithm development into something more akin to assembling puzzle pieces, and I’ll give some pointers on how to do that. I’ll show how you can construct your data types so that meaningless, “impossible”, or other error conditions cannot even be represented in your structures and the awesome effects that can have on your code. I’ll walk through a couple examples to illustrate the techniques.
My examples will be in Haskell but the ideas and techniques should apply to any language with Hindley-Milner type inference, especially those with constructs similar to Haskells’ type classes.

Where is your domain model? – Baraa Basata

ROOM W2-69  3:25 pm to 4:25 pm

A domain model is much more than the “M” in MVC. As Martin Fowler writes, “Learning how to design and use a Domain Model is a significant exercise–one that has led to many articles on the ‘paradigm shift’ of objects use.”

Let’s talk about evolving a domain model in sustainable ways that allow a codebase to organically grow in a way that supports agility and adaptability. Highlights include:

* What is a domain model? What are the alternatives?
* What is sustainable software development?
* Ubiquitous language, and thinking twice about naming something a Manager, Service, or DAO
* Sharing objects between client and server?
* Why mock objects?
* Bringing it together with outside-in test-driven development

Examples are in Ruby, JavaScript, and Java, but this is not a language-specific session.

Your Asynchronous Future – Bill Wagner

ROOM W2-63  1:10 pm to 2:10 pm

.NET 4.5 and C# 5 introduce new idioms for asynchronous programming. We’ve had the Asynchronous Programming Model (BeginDoSomething, EndDoSomething and IAsyncResult). We’ve had the Event Based Asynchronous Pattern (OnDoSomethingCompleted), and the Task based library in .NET 4. The latest update to the language and libraries provides language support for asynchronous programming, enabling you to concentrate on you core algorithms instead of the plumbing of asynchronous programming models. It makes asynchronous programming easier, but not necessarily easy.

In this session, we’ll go over the most common practices for asynchronous programming, and a number of techniques that will help you create more correct and more maintainable asynchronous programs. We’ll also briefly discuss how these techniques translate to WinRT and Metro.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s