Fall 2011 - Sessions

Here's a list of session titles currently submitted. Note that the final list may not contain all of the session ideas.

So You Want to Create Your Own Rock Band Tracks - Ken Sykora

Having its roots with Guitar Hero, Rock Band has become the preimiere musical genre video game. With hundreds of songs available for download already, there are always room for more awesome tracks. In this session, you'll be walked through the building blocks of authoring tracks for the Rock Band Network, from the tools, to the authoring, to play testing, to releasing a track on the RBN itself.

Introduction to Apache Hadoop - Brock Noland

Are you Hadoop curious? If so, this session is for you. Apache Hadoop and "big data" are the hottest buzz words in the IT space. In this session, we will discuss the Hadoop architecture and then dive right into working code examples to solve increasingly complex problems. The problems we intend to tackle are word count, analytics, and finally handling updates with no random write functionality. All attendees will be given the code discussed in class and a downloadable virtual machine ready to execute the code examples discussed in class.

Common and Unique Apache Hadoop Use Cases - Brock Noland

OK, so you are aware what Apache Hadoop is, but you are struggling to understand where and when it should be used? Is it a replacement for the database, part of the "cloud", or useful for my problems? In this session we will briefly discuss common Hadoop deployments both physical and virtual and then follow that up with an in depth discussion of the code which implements two common use cases and one unique use case. Learning by code, we will pick apart Data Warehouse Integration, Cheap and Deep Storage, and Stitching Maps Together. All attendees will be given the code discussed in class and a downloadable virtual machine ready to execute the code examples discussed in class.

Microsoft Dynamics CRM Development and Integration - Jamie Miley

Microsoft Dynamics CRM development has become a highly sought after niche skill in the .NET space that is probably second only to SharePoint development right now. We will cover the fundamentals of Microsoft Dynamics CRM development from both the client-side and server-side perspectives and we will also explore how this versatile platform can be easily integrated with Microsoft SharePoint and Microsoft Azure.

Introduction to WCF Rest Services - Brian Gorman

In this session, we'll discuss ground-up implementation of WCF Rest as a powerful tool for interaction between projects and the database. We'll start by implementing a service for error logging, and show how this service can be hosted in IIS, through a windows service, and via AppHarbor. We'll focus on the methods that need to be created, how to configure the service, and how to interact with the service. We'll conclude by showing how to build a reusable library to easily implement server-side ASP.Net and Winforms client interaction, as well as discuss using JQuery to interact with the service on client-side web pages. Projects will be built in C#.net

Introduction to Design Patterns - Brian Gorman

In this session, we'll discuss popular and powerful design patterns, including the Strategy pattern, Decorator pattern, and the Factory pattern. We'll use C# as our language of choice during this session, however design patterns are language agnostic, so any object-oriented programming language can implement these patterns. Design patterns are very useful in your projects because they allow for more robust solutions while minimizing the pain of maintenance and trouble-shooting, as well as minimizing (eliminating?) repetitive code.

Level-Up Your Win7 Kinect Apps - Mike Hodnick

You've downloaded the Kinect SDK for Windows, you've played with the samples, and you've even written your own crude Kinect app in Windows 7. In this 200-level session we'll take Kinect programming to the next level and discuss qualities of motion-based Natural User Interface (NUI) apps that will help turn your Kinect app into a pleasing user experience. We'll talk about good patterns for incorporating the Kinect runtime in WPF applications, how to deal with noisy background user traffic, speech recognition, creative ways to utilize the runtime, and other topics

Introduction to Cross-Platform .NET Development - TBD

The .NET framework is perhaps the most extensible, and stable way to go about cross-platform development. Unlike native languages, it offers a byte-code which can be JITted to high-performance native code at runtime, and offers near-native speeds on various platforms such as Windows Phone, Windows 98-Windows 7, Windows 8, and Linux. Although the same byte-code can be run on all platforms, the difficulty is often finding libraries that will work on all these platforms, without the need to re-write your code for each one. In this session, I will be introducing a cross-platform library, which works seamlessly across all these platforms, and can be used to write high-performance games, and other 3D applications for all the platforms above. This project is currently available as an open-source library on Github, and anyone is welcome to contribute to it.

What's New in Windows Azure Release 1.5 - Mike Benkovich

Windows Azure is Microsoft's Cloud Solution for Platform as a Service (PaaS) that allows developers to build solutions that take advantage of the scalability, performance and distribution promises of the cloud. In this talk we'll dive into what is new with the latest release of the SDK, the tools for Visual Studio, and the Management Portal. We will explore how to deploy, configure and scale applications, as well as explore new features like Geo Replication, Traffic Manager and the Service Bus.

Static Analysis in .NET - Jason Bock

We all want to have someone else review our code to make sure it's written well. Wouldn't it be even better if we can have that review process done automatically? In this session, you'll see how you can use static analysis tools (like Code Analysis/FxCop) to find all kinds of implementation issues before they show up in a release. You'll also find out how to manage rule sets in Visual Studio, and find out how you can create your own custom rules.

Windows Phone Development with "Mango" - Jeff Brand

This is an introduction to developing an application on Windows Phone "Mango". After a brief introduction to general development and tools, the session will spend time looking at the new features of the Mango release.

Expression Blend for Developers - Jeff Brand

This session will take a look at why XAML developers should be using Expression Blend. Focused on apps that use MVVM, we’ll take a look at things like sample data, markup based dependency injection, styling, templating, and more.

Digging Deeper into jQuery - Brad Candell

Have you found yourself leveraging the power and flexibility of the jQuery framework more and more? Are you looking for ways to take a basic understanding of the core features, and improve upon them? In this presentation, we are going to focus on a few of the more advanced topics surrounding jQuery with the intent of improving the efficiency of your development cycle, the usability of your application, and your reliability through testing. Look forward to learning about Ajax, plugin development, theming (theme roller), client-side validation, data templating, the jQuery Mobile Project, and unit testing. Viva-la-Highlighter!

MVVM Light Toolkit - Scott K. Davis

The MVVM design pattern quickly became the defacto approach for building WPF and Silverlight applications. But, are you also using the MVVM Light Toolkit? The MVVM LightToolkit helps to avoid memory leaks, creates safe property notifications, allows for flexible eventing, and more. Most importantly, MVVM Light Toolkit is a small resource that can be added to any existing project without requiring rearchitecture of your existing code. In this session we will explore the benefits of using the MVVM Light toolkit in your WPF, Silverlight, and Windows Phone applications.

XNA-Based Game Engine - Larry Louisiana

We will talk slightly about what XNA is and does then we will dive into the internals and code a IOC based XNA base framework and develop a little game all in the session. We will cover IOC in XNA, the component based approach to game development and general XNA pitfalls. We will create a simple side scrolling space ship game, then show how to improve it.

Windows Identity Foundation (WIF) - Larry Louisiana

An introduction into claims based authentication and SSO. We will discuss what SSO is in the realm of WIF (no pun intended). We will discuss some of the ins and outs of how to get this set up, as well as where to go for help.

Modding The Elder Scrolls IV: Oblivion - Matt Christian

Just in time for the release of the anticipated game The Elder Scrolls V: Skyrim, learn the basics of the tools Bethesda used to build the last entry in the massively successful role-playing series, The Elder Scrolls IV: Oblivion. This session will provide an introduction to The Elder Scrolls Construction Set and include developing quests, writing game scripts, and implementing custom dialogue.

Web Development Recipes - Brian Hogan, Mike Weber , Chris Johnson and Aaron Godin

Modern web development takes more than just HTML and CSS with a little JavaScript mixed in. Clients want more responsive sites with faster interfaces that work on multiple devices, and you need the latest tools and techniques to make that happen. Our talk will include some web development recipes to get you introduced to some of the best tools for web development. This talk is not focused on a specific language, but is targeted for the modern day web developer. We'll cover topics that can be used with most modern day frameworks and languages, so you can expand your .NET, PHP or Ruby site to have some fun new features.

Silverlight Motion Detector for Windows 7 and Windows Phone - Jeff Klawiter

Ever want to know if someone is heading towards your cube/office/domicile before they appear behind you scaring the crap out of ya? Here's your chance to learn how to build a motion detection application yourself. Using the Native Extensions for Silverlight and Silverlight Out Of Browser we will build a program that will utilize features of Windows 7 to let you know when motion was detected. As an added bonus we will go over porting the application to Windows Phone 7 Mango taking advantage of the new raw camera access.

Software Estimating Tips from the Trenches - Avonelle Lovhaug

"When will it be done?" is the question most dreaded by software developers. You may think the most important tools for creating software estimates area crystal ball and a divining rod, but there is a better way that won't involve magic. Plus, accurate software development estimates can enhance your professional image in your organization, and make life better by eliminating the mad dash at the end of the project. This session will improve your estimating accuracy by teaching you several techniques that I've learned through my 16+ years as a software consultant. It will also show you how to handle situations where an accurate estimate isn't possible.

Making the Leap to Freelance Programming - Avonelle Lovhaug

Have you ever felt like your day job just might not be for you? In this session, Avonelle Lovhaug will cover all the basics that you need to know to start your own freelance programming business. You'll learn how to find your perfect client, some non-sleazy marketing techniques, and how to get paid what you're really worth. We'll also cover setting rules and boundaries for your business, and some ideas for regular income that can help you to avoid the feast or famine cycle that plagues most freelancers.

Introduction to Unit Testing: Making Developers Happy and Software Awesome - Todd H. Gardner

Are there dark, scary corners of the code you fear to tread? Do bugs multiply when you squash them? Unit tests provide constant developer feedback that will make developers happy, and your software awesome. This session will introduce the concepts and structure of Unit Testing with examples in C# and Javascript.

Creating DSLs with meta# - Justin Chase

There has been a surge in conversations about Domain Specific languages and DSL technology in the last couple of years. This talk is for language enthusiasts and those curious about how they can harness Domain Specific Languages today. I will talk a little bit about what DSLs are and why you should be interested in them and then delve into how you can use meta# to create your own DSLs.

Implementing Messaging Patterns in JavaScript Using the OpenAjax Hub - Kevin Hakanson

Is your web application a tightly coupled, DOM event handler mess? Use techniques from the Enterprise Integration Patterns book to build better components. Concepts including Message, Publish-Subscribe Channel, Request-Reply and Message Filter will be demonstrated in JavaScript (along with corresponding QUnit tests) using the OpenAjax Hub.

Intro to HTML5 Canvas: A Crash Course - Kevin Moot

We will unlock the HTML5 <canvas> element and illustrate what can be accomplished via its 2D API. Following a brief history of canvas, we will cover basic drawing commands, matrix transformations, image processing via pixel manipulation, real-time video effects, and show a step-by-step example of how to construct an animated scene in canvas. The talk will also feature a comparison other web graphics technologies such as Flash, and highlight the applications best suited for canvas.

Getting Dirty with Windows Phone 7 - Brent Edwards

You've downloaded all the tools and know how to publish an app for Windows Phone 7. The IDE is ready to go and you have a killer idea. Now what? In this session, we will talk about many of the key concepts you will need to understand to develop good applications for Windows Phone 7. This will be a code-heavy session where we will be getting our hands dirty to illustrate these foundational concepts in action.

Practical Monads in C#: Maybe<T> - Jordan Terrell

Blog posts and videos have had much to say about Monads. Learning about Monads often leads to explanations full of complex mathematical and Haskell notations. This talk will show the practical side of Monads - how they can be used in everyday programming tasks. A brief amount of time will be spent on what a Monad is and what it is not, as well as what Monads already exist in the .NET framework. This talk will focus on demonstrating an implementation of the Maybe monad in C#, Maybe<T>, and specific examples on how it can be used in your projects.

Exodata: Ioc for Data - Jordan Terrell

Inversion of Control (IoC) frameworks and libraries abound for the .NET framework. These are very useful for decoupling service providers from service consumers. Exodata takes this concept of decoupling providers from consumers and applies it to data retrieval. An enhanced vocabulary for IoC in general will be introduced and numerous code examples will be presented to explain what Exodata is, how it is implemented, and practical ways that it can be used in real projects.

F# > C# - What F# Does That You Can't (Easily) do in C# - Aaron Erickson

You have heard the arguments. When you get down to it, it is all IL, right? Doesn't that make C# and F# the same? Hogwash! In this talk, we will explore those areas where F# has distinct advantages over F#, including:

  • Immutability by default
  • Domain on a page
  • Pattern matching
  • Computation expressions
  • The eradication of null

Use what you learn from this talk to be able to, very confidently, make the case for F# to your friends, your colleagues, and greater "powers-that-be". Or at least understand why you should stop putting off that nagging "finally learn F#" to-do item that has been in the back of your head all these years.

You Can Do What in Windows Azure?! - Adam Grocholski

You already know you can run your .NET based web sites, service, and applications on Windows Azure, but this only scratches the surface of what you can do. Encoding video with Expression Encoder, hosting adaptive streaming video in blob storage, hosting multiple web sites, enabling remote desktop, creating a VPN and more are all possible with the Windows Azure platform. In this demo intensive session I'll show you how to do these things and more to unleash the power of Azure.

Understanding Relational Databases for Maximizing Application Performance - David Berry

Database performance remains a critical factor in overall application performance and scalability. This session is targeted at application developers who wish improve their understanding of database performance and how applications interact with the database. This session will target SQL Server, though the concepts are applicable to most large scale enterprise databases. This session will focus on how to query SQL Server's Dynamic Management Views (DMV's) to identify the performance bottlenecks in an application. It will also cover how to interpret how the database is processing your queries and how to tune your queries to run faster. Finally, I'll cover some of the most common database performance issues encountered by application teams and discuss some strategies for addressing them.

Introduction to Powershell - Loren Halvorson

Learn how to use Powershell to automate just about anything. We will learn to use the Powershell discovery, object manipulation, and transformation utilities and demonstrate how to script against .NET, COM, WMI and XML. We will also see how easy it is to host Powershell in your own application, and much more. Real examples of using Powershell to automate tedious developer tasks will be explored.

Javascript: History and Functional Awesomesauce - Walker Wilkins

Javascript has been one of the most hated languages of modern times, but the emergence of ajax has forced people to *gasp* actually learn the language. I'll talk about the history of javascript from it's origins to the present and review the parts of javascript that have allowed many developers to call a truce in the javascript hate war and use it for serious web development. We'll focus on prototypical inheritance and Javascript's features derived from functional programming models. At the end, we will look at one terrible peice of code and transform it into something much better.

KnockoutJS: Web Development Bliss - Judah Himango

Oh yes. Web development is evolving, and KnockoutJS is at the fore, granting you powerful new capabilities like HTML data-binding, templating, automatic UI refresh, and implicit dependency tracking. Minimizing classic pains in web dev, Knockout lets you say goodbye to ugly DOM manipulation, begone to UI state tracking, and hello to clean object-oriented JavaScript. In this code-heavy session, you'll learn how to use Knockout's secret arts to build web apps that stand above the fold.

Web Development with CoffeeScript and Sass - Brian Hogan

The web runs on CSS and JavaScript, but JavaScript can be clunky, and CSS is a mess. Sass and CoffeeScript take these technologies and crank them up. In this talk, you'll learn how to use CoffeeScript to build JavaScript applications using a concise but powerful syntax. And you'll learn how to make your CSS much easier to maintain using powerful Sass features like variables, functions, and iteration. Then we'll discuss how to build these into your workflow so you can take advantage of them right now.

Cross-Platform Mobile Development for the Enterprise: Building Applications with .NET/C# and Mono - Kenny Goers

The mobile world has collided with your enterprise and now you are being told all your internal applications need to go mobile, and depending on your environment, it might be iPhones and iPads with iOS, Android phones or tablets, Windows Phones and maybe HTML5 with anything else. Worst of all, most of the custom code you write is in C# and who has time to learn and support Java, ObjectiveC and C#? Well, we've got some answers for you using MonoTouch, Mono for Android and .NET/C#. In this session we will build an MVC application with common Models and Controllers, but will device specific Views for iOS, Android and Windows Phone 7 and if time allows a HTML5 interface as well. Hold on it will be a wild ride!

HTML5 Graphics: Pretty Pictures for Practical Processes - Jon Stonecash

With the advent of HTML5 modern browsers can create advanced graphics on a web page. The <canvas> and <svg> tags allow the web page to create sophisticated charts and diagrams. These images are more than just pretty pictures. It is possible to allow the user to interact with these images and to have these interactions affect the more traditional elements of the web page such as form, input and control elements. This presentation explores the possibilities and the mechanisms for integrating interactive images into line of business web applications, using the canvas and SVG elements plus a liberal dose of jQuery and JavaScript. The framework for demonstrating these techniques will be ASP.NET MVC but the material can be used in any web server technology.

Distributed Version Control: Attack of the Clones - Keith Dahlby

Everyone needs version control, but does it really matter what you use? As distributed systems like Git and Mercurial have taught us, it turns out it matters quite a bit. This talk will review the core concepts of distributed version control, show off a few advanced features you didn't know you needed, and discuss options for getting started now rather than later.

Getting Func-y with C# and F# - Keith Dahlby

Despite its genesis nearly 60 years ago, functional programming has only recently reemerged as a core technique in mainstream languages. This session will contrast the functional style with imperative and object-oriented programming and dive into real-world examples of how it can be used to solve common problems in C# and F#.

What Can Windows Workflow 4 do For You? - Chad Kulesa

You've probably heard of Windows Workflow, and maybe even tried it out. But you weren't sure what to use it for, or how to use it properly. Perhaps you wondered why you'd want to use Windows Workflow instead of just writing code. In this session we will go over the basics of using Windows Workflow. In addition, we will cover some common use cases where Windows Workflow can simplify development and save you time while increasingthe flexibility of your software.

A First Look at Silverlight 5 - Vince Bullinger

Microsoft recently released the first release candidate for Silverlight 5. In this session, we'll go over all of the most interesting new items in Silverlight, including 64-bit support, Postscript-based vector printing, MediaCommand support, the DataContextChanged event, in-browser trusted applications, PivotViewer control and power awareness for media apps.

WCF Web API - Nazmul Siddiqui

The REST service model has progressively gained industry wide exposure and WCF support for it is no different, as it continues to inch toward becoming a first class service model within the WCF environment. Web API is effectively the next WCF iteration for REST support. While Web API offers a more comprehensive feature set on par with SOAP based service models, upgrading from existing WCF REST model to the Web API model is practically painless. The nearly ground up Web API service model intends to bridge any remaining gaps when compared to its SOAP counterpart and push the envelope. We'll introduce and explore the API in some detail with discussions, demos, and samples.

Introduction to iPhone Development with C# & MonoTouch - Jaim Zuber

"Great job with your MVC/Sliverlight/Whatever app! We're going to need that on the iPhone too. How long will that take?" Have you run into this question yet? You will. This session will help you wade through the staggering number of development options available and give you the info needed to make the right decisions for your Client, Product or Organization. We'll start with an overview of the Mobile ecosystem and the basic concepts of the Cocoa Touch framework. From there we'll dig into MonoTouch and show the power and flexibility it provides over native Objective-C development. We'll also give a tour of some time saving libraries like MonoTouch.Dialog that, well, just make our lives easier.

Writing Clojure Macros - Kurt Christensen

Clojure is a relatively new dialect of Lisp which runs on the JVM as well as the CLR. Perhaps the most powerful feature of Lisp is its ability to define macros to create syntactic abstractions. In this presentation, Kurt Christensen will explain what macros are and why you might want to create them, along with some tips and tricks for writing and debugging Clojure macros.

Building Metro-style applications for Windows 8 - Steve Peterson

A few weeks ago, Microsoft released details on Windows 8 for developers. Come to this session and learn about different approaches for building Metro-style applications for Windows 8, from a member of the Visual Studio / Expression engineering team.

Samba in the Age of Microsoft Glasnost - Christopher Hertel

Microsoft recently announced Version 2.2 of the venerable SMB network file system protocol. Features of SMB2.2 include multipath support, cluster capabilities, distributed caching, and SMB over RDMA--cool stuff. How will these advanced features impact the storage market, and what jobs are likely to be created? How will the Samba Team--which was at one point ahead of Microsoft in clustering features--respond? Most of all, what does SMB2.2 actually look like on the wire and how do coders break into the illusive SMB/CIFS/SMB2 development community?