A Walk on the Wild Side: Imposing Structure on an Unstructured World

by Jon Stonecash

Presentation Materials

One definition of programming is the extraction of formal structure from unstructured situations. The "real world" is chaotic. When we develop software, we abstract from this messy maelstrom to build database tables and software objects that are, at least relatively, more structured. But it is impossible to eliminate the mess. Anyone who writes that part of the application that accepts data at the "edge" of the application knows just how messy it can be. There are three ways that the application design can respond to the data entry problem:

• Reduce the complexity of the data entry by requiring the user to parse the data into individual textboxes that are so simple as to be un-interesting. If you build applications this way, turn your head away in shame. Stand tall and say, "I will not make my users do work that the computer software can and should be doing."
• Build logic to parse the mess and extract as much of the meaning from the maelstrom. This is fun, interesting, and useful. There are several ways of doing this and each way leads to lots of opportunities to show you some code.
• Add structure under the covers by using "micro formats". Again, this is a good thing that lends itself to more opportunities to show you some code.

Just so you won't think parsing and micro formats are only for the "fancy folk", we will look at parsing and micro formats to deal with common data entry items such as addresses and phone numbers. These "ordinary data entry problems" can be very difficult to solve in the general case. We will parse these items with regular expressions, programmatic state machines, and formal parsers, noting the wonders and woes of each approach. Once you have struggled with handing the entry of these items, you should be motivated to make it easier for others by tagging your output using "micro formats" that vastly reduce the effort for other programs to accept the output your applications produce.

Become the Master of Your Domain with Domain Specific Languages

by Justin Chase

This talk will explore the benefits of creating Domain Specific Languages, talk about how existing DSLs affect us everyday and discuss how different types of DSLs can be implemented. We will talk about practical examples of how to create DSLs of various styles including fluent interfaces, External DSLs with MGrammar and Internal DSLs with Boo and Boo Ometa.

Building a Dynamic Game Engine in XNA: Giving Power Back to the Creators

by Matthew Christian

In this talk, different methods for implementing a dynamic game engine are introduced. Such examples include loading game menus through XML, generating 2D levels with simple text files, and using other file formats to generate game levels, menus, etc... The primary focus of this talk is to show implementations of code that pull data from other sources to build simple games. Note, the specifics of XNA won't be detailed in this discussion unless absolutely necessary.

Building Better Applications with UX Principles

by Corey Miller

I will talk about some of the UX principles and practices and how we as business application developers can use these concepts to help build better applications for our users. This session will be a tips, tricks, and lessons learned session on building better UI's.

Code-Free WPF Data Binding

by Kirstin Juhl

WPF provides a new paradigm for data binding in your application. Learn how to bind elements to a variety of data sources right from the XAML mark-up without a single line of code. In this presentation we will bind to a variety of data sources in the form of common language runtime (CLR) objects and XML.

Creating Build Processes with MSBuild 3.5 and Team Foundation Server 2008 SP1

by Dan Sniderman

An important "best practice" for any mature software organization is to automate the build process for applications. Dan Sniderman will show why and how to automate your builds using Microsoft Team Foundation Server. This presentation will include a brief introduction to MSBuild and has a hands-on demo of setting, extending and customization builds in TFS.

DemoFEST: SQL 2008, AJAX and the Virtual Earth SDK

by Mike Benkovich

In DemoFest events, we demonstrate an end-to-end solution that takes technologies and tools we discussed in other BenkoTips webcasts and applies them to create something fun. We look at some of the new features in Microsoft SQL Server 2008, including data types for spatial data, and how we can use these features to build interesting applications. We then take this functionality and expose it using a Windows Communication Foundation (WCF) service. Finally, we explore the software development kit (SDK) for Microsoft Virtual Earth and how we can build on top of this rich interactive platform using new Asynchronous JavaScript and XML (AJAX) and JavaScripting capabilities in Microsoft Visual Studio 2008.

Developing for Windows Mobile Devices

by

Mobile development is growing fast, and Windows Mobile is at the forefront with over 18 million phones shipped last year and many more cutting-edge devices on the way. Visual Studio developers have tremendous opportunities in this space. Why? Developing for a Windows Mobile phone leverages your existing coding experience and takes it to new heights. In this session, we'll look at some of the coolest new devices, you'll learn how to set up Visual Studio with the latest SDK and device emulators, and you'll see how to build, deploy and debug Windows Mobile applications. We'll work with building a realistic application, working with data and finally packaging it up.

Firefox Extensions: Making Your Web Application More Accessible

by Kevin Gisi

Presentation Materials

What web application could be complete without a convenient interface? We'll walk through an example of how to write a Firefox extension for your latest project, using the already-familiar Javascript, CSS, and XML.

Groovy Metaprogramming

by Hamlet D'Arcy

Presentation Materials

Ruby's monkeypatching brought the idea of metaprogramming to the masses, or at least to those that weren't exposed to it in Lisp or C. At its best, metaprogramming can greatly improve productivity, as is the case with Grails, but at its worst it can destroy expectations and induce versioning confusion. This talk introduces the myriad metaprogramming techniques Groovy and dynamic typing allows, shows how some of them are used in real life, and compares them to what's available in other languages. Oh yeah, all code will be written live.

Implementing Presentation Patterns that Truly Work Across Platforms

by Adam Grocholski

Presentation Materials

In layered applications, the presentation layer is just as important as navigation logic, business logic, and data access. While you should try to keep the presentation layer independent from the UI technology and platform in order to improve testability, it's not always easy to do. Design patterns can help. In this session I'll discuss design patterns such as Model View Controller (MVC) and Model View Presenter (MVP) for building presentation layers that can truly be used across multiple platforms, including WPF, Silverlight and Windows Mobile, and in Software as a Service (SaaS) scenarios.

Increasing your Productivity with Visual Studio

by Jeff Klawiter

Presentation Materials

Visual Studio is one of the greatest development environments out there. It includes many shortcuts and features to make your life easier as a developer. Some of those features are not always user friendly to get set up. The main focus will be on using snippets to improve your development experience with common patterns in LINQ and data objects. We will also cover various shortcuts and windows. No one is an expert, you will be encouraged to share your own tips and tricks.

Intro to iPhone Development

by Dan Bennett

Presentation Materials

In this presentation we'll cover the basics of creating a simple iPhone weather application using XCode, InterfaceBuilder & Yahoo.

Introduction to F#

by Keith Dahlby

With Visual Studio 2010, F# will officially become a first-class citizen in the .NET development ecosystem. This session will explore functional programming, why it matters in an object-oriented world, and how F# bridges the gap. I will also discuss some lessons learned from using F# with OpenCV, an unmanaged computer vision library.

Introduction to the Building Composite WPF Applications

by Jefferson Brand

This session will introduce you to the WPF Composite Application Library. Using the Comp App Library, developers can quickly build a WPF application that can be extended with customized UI modules, services, events, and more. We will take a look at getting a Composite Application initialized, adding custom modules, building views, and coordinating services and UI interactions using the CAL.

Learning to Walk in Shoes - A Fun and Easy Framework for Cross-Platform GUI Apps

by Brian Hogan

When you're using Shoes, programming is really fun again. Shoes is a simple yet powerful application framework for developing cross-platform desktop applications. In just a few lines of code, you can be pulling feeds from Twitter, and in a few more, you can be grabbing videos from YouTube. Kids as young as five years old are learning to program using Shoes because it's so easy and comfortable, but it's also extremely flexible too. You can use it to check on the status of your servers or as a frontend to pushing code into production. In this session, you'll learn about the Shoes framework and see how easy it is to build something fun and useful.

Practical Parallelism

by Rockford Lhotka

With multi-core computers becoming commonplace, and technologies like Silverlight requiring the use of asynchronous programming, and the use of distributed service-based computing spreading, we are entering an era where parallel and concurrent programming is virtually required. Are you ready to be multi-threaded? Parallel? Concurrent? Are you ready to build applications that are not only parallel, but distributed? This session will discuss the drivers of this change, the challenges we face, and some of the solutions available today and in the near future on the Microsoft .NET platform.

Rails and Legacy Databases

by Chris Johnson

Have you been to Ruby on Rails talks and found the framework interesting? Do you want to use Ruby on Rails for your next project but have to connect to a legacy database and don't know if Rails will work? Rails' object relational mapping allows to connect to legacy databases easily and use rails conventions to build your web application, without disrupting the database. During this talk we will look at a very hideous database (something that I hope no one will ever see) and build a simple rails application on top of it. This demo will revolve around using SQL Server 2005.

Real World ASP.NET MVC

by Gus Emery

With the addition of the new ASP.NET MVC framework there will be a lot of questions surrounding how this technology can be used instead of the Web Forms that we all have been used to since .NET 1.0. With the addition of the MVC Framework we now have the best of the old world ASP Classic, with a compiled and easier to debug workspace. This session will cover a quick overview of the MVC framework, and continue with building a 'Real World' application. The message that will be carried from within the session will be how the MVC Framework can be harnessed in future projects within the attendee's future projects. This will be a "Must See" session for any web developer looking to the future.

Self-Writing Programs - Using Expressions in C# to Write Code that Writes Code

by Aaron Erickson

While most of us were looking at new features like Linq when C# 3.0 and VB9 came out, behind the scenes, a much more interesting and powerful feature snuck in - the ability to write programs that literally write themselves! In this session, we explore how to write programs that write themselves using the classes in the System.Linq.Expressions namespace. These classes allow you to evaluate code at runtime and even write new code at runtime - without having to resort to IL generation (why should Lisp hackers get all the fun?). You will learn how to use the classes in the namespace, how they work together, as well as some examples of how such things can be useful in ordinary line of business applications.

Silverlight and the Farseer Physics Engine

by Mike Hodnick

Presentation Materials

In this code and demo-heavy session, you will learn how to use the Farseer Physics engine with Silverlight to create dynamic and unique scenes in a browser. We'll wire up the Farseer engine to the UI, handle collisions, join physics bodies together, and control parameters such as gravity and friction. Presenting data and offering a user interface with physics-like qualities is becoming commonplace in cutting edge applications, and the Farseer engine with Silverlight is one way to deliver that experience.

Silverlight Development: Lessons from the Trenches

by D'Arcy Lussier

So what's it like creating a line of business application using Silverlight? What are the differences in developing a Silverlight application compared to a Winform or ASP.NET based application? In this session I'll share with you my experiences in creating a real-world Silverlight based application and what you should expect/look out for when developing with this exciting new technology.

Surface Is Hot!

by Brian Lockwood

Stop, drop and roll your way into Microsoft Surface development. This session will focus on what Microsoft Surface is, how to interact with it, and what language drives it. The session will finish up with a simple code demonstration to hose it all down. [Note: The speaker is opposite of wealthy so there will not be an actual Microsoft Surface unit, the demonstrations will be done using the Surface Emulator]

Testing with Mocks

by Donn Felker

Presentation Materials

Test this, test that, no problem. But what about when we need to start building full object graphs into our test in order to test an interaction or state? Yeah, Houston, we have a problem. With mocks we can streamline development by mocking out dependencies. Mocks will allow us to not only mock our dependencies but to also test our interactions and state very easily. In this session learn how to use mocks in your day to day testing.

Working with WPF (aka "Let's build yet another Twitter application.")

by Cory Smith

This session we will start from scratch and build a functional Twitter desktop application using WPF. Along the way, I'll share some of the lessons learned thus far as a newb WPF / experienced Win32 developer.