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
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!
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.
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.
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 -
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
"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
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.
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
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.
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# -
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 -
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.
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.
of ajax has forced people to *gasp* actually learn the language. I'll talk about
hate war and use it for serious web development. We'll focus on prototypical inheritance
we will look at one terrible peice of code and transform it into something much
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
how to use Knockout's secret arts to build web apps that stand above the fold.
Web Development with CoffeeScript and Sass - Brian Hogan
Sass and CoffeeScript take these technologies and crank them up. In this talk, you'll
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 -
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
these techniques will be ASP.NET MVC but the material can be used in any web server
Distributed Version Control: Attack of the Clones - Keith
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.
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,
Introduction to iPhone Development with C# & MonoTouch -
"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.
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
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?