DoDN header image
ITTF header image


(October 23, 2010)

NoSQL: I can’t relate to my database, anymore Speaker: Dennis Burton
Abstract: It’s not you, it’s me. Or rather, my needs have changed. The kind of apps we build today are different than the ones we built two decades ago. The scale requirements are different as are the levels of abstraction we work with. Relational databases are not our only option. The NoSQL movement is coming to an app near you. Will you be ready? In this session we will look at some non-relational databases with a focus on the document database style using MongoDB. Scalability may get your attention, but there is more to the story. See what happens when we take another perspective on persistence.

Write your first WPF Application Speaker: Michael Eaton
Abstract: Are you tired of sitting through WPF/XAML introductions that do nothing but show you how to create spinning ghosts and gradient fills? Are you ready to for an introduction to WPF / XAML that focuses on real-world usage? This session will include an overview of XAML, containers and commonly used controls found in WPF. This talk expects no knowledge of WPF.

Developer Tools for Sharepoint 2010 Speaker: Sam Nasr
Abstract: With the release of Visual Studio 2010 along with SharePoint in a narrow time frame, many tools are now available to make custom development in SharePoint easier. Leveraging the same knowledge from prior versions of SharePoint, developers can now easily create tasks once known to be difficult. With features like visual designers, packaging and deployment support, project, and item templates make SharePoint development simpler and faster.

Going for Speed: Testing for Performance Speaker: Jay Harris
Abstract: Unit Testing has settled into the mainstream. As developers, we write code that checks code, ensuring that the outcome matches some expected result. But, are we really? As end-users (which includes each one of us from time to time), when we ask a question, we don't just expect our answer to be right, we expect it to be right now. So as developers, why are we only validating for accuracy? Why aren't we going for speed? During this session we'll discuss meeting the performance needs of an application, including developing a performance specification, measuring application performance from stand-alone testing through unit testing, using tools ranging from Team Foundation Server to the command line, and asserting on these measurements to ensure that all expectations are met. Your application does "right." Let's focus on "right now."

Beginning Module Development with Dot Net Nuke Speaker: Jeff McWherter
Abstract: You may have heard that the DNN framework is a great tool for bringing up a web application in no time flat. You also may have thought, “What happens when I can’t find a module to do exactly what I’m looking for?” In this session, Jeff will discuss the basics for getting started developing your own DNN modules. Along with the basics, Jeff will throw in a few tricks about development, testing and oddities in the DNN API that have come from years of module development experience.

Building Your First ASP.Net MVC Application Speaker: David Giard
Abstract: This session walks through the basics of creating an ASP.Net MVC application. I describe how the model, view and controller relate to one another; how to create each component; the conventions used in MVC; and the URL routing engine. We will build a simple application that uses this framework.

Parallel Without Pain: Parallel Programming in .NET 4.0 Speaker: Jennifer Marsman
Abstract: Parallel programming is hard. It’s difficult to look at a piece of code and grok how 32 instances of it running simultaneously will behave. However, as the hardware industry shifts towards multi-core and manycore processors, the key to high-performance applications is parallelism. The .NET Framework 4 and Visual Studio 2010 offer solutions to make coding, debugging, and profiling concurrent applications significantly easier. In this talk, we’ll examine Parallel LINQ-to-Objects (PLINQ), the Task Parallel Library (TPL), new coordination and synchronization types, and Visual Studio tooling support in order to provide a look at the next generation of parallel programming with .NET.

Skill Shifting: Moving from .Net to iPhone development Speaker: Dan Woolston
Abstract: A one hour talk on why .Net developers make great iPhone application builders. We'll take a look at the Apple branded tools, sample code and build a small app along the way. This talk is NOT about MonoTouch or other third party development tools. It will be a discussion on the transition that many developers are asked to make as the portable market takes off and I.T. managers scramble to implement mobile solutions with current resources.

Examining a Real World Silverlight Application Speaker: John Hauck
Abstract: This session will examine a real world Silverlight application written in C# and XAML using the Model-View-ViewModel (MVVM) design pattern. The application was developed for Premier Junior Tour, a company that conducts nationally-ranked golf tournaments throughout the state of Florida. We will cover the various aspects of this application including the Views (XAML), Data and Command Bindings, Models, ViewModels, Data retrieval with WebClient, and Linq. All source code will be made available to interested participants. See the Silverlight application in action here:

Leveraging Dependency Injection in .Net Applications Speaker: Nick McCollum
Abstract: Frequently, when an instance of a class is created it must also be configured after creation before it can be used. The goal of the abstract factory design pattern is to encapsulate the creation and configuration of the object in one location so it can be reused throughout the application. This eliminates the need to repeat the configuration code in every component that wishes to create an instance of the class. This approach abstracts the creation and configuration of the instance from the calling components allowing the implementation to be changed at any point in time without affecting the calling components. Traditionally, the factory pattern is implemented as a static class with a series of static methods that return instances of objects. One of the drawbacks of this traditional implementation of the abstract factory design pattern is that the factory class must know which concrete class to instantiate as well as how to instantiate any dependent classes it needs. A dependency injection container removes this issue by allowing the implementation class and its dependent classes to be specified in a configuration file and injected into the factory class at runtime. In this session we will examine two dependency injection containers available for .Net applications, Spring.Net and the Unity application block included in the Microsoft Enterprise Library.

Beyond Web 2.0 APIs : Implementing RESTful Hypermedia for .NET Web Applications Speaker: Mike Amundsen
Abstract: As more and more data is exposed to the web, many developers find themselves building yet another Web 2.0 custom API and a custom client to match. All is fine until a change is required in the data format, the contents of a record, or the workflow of the application. Then, all bets are off and you start from the beginning again. Wasn’t HTTP/REST supposed to solve all that? In this talk, you’ll learn to implement RESTful .NET applications using Hypermedia instead of typical Web 2.0 APIs. You’ll learn how to create a single hypermedia definition that serves RIA, Desktop application, and traditional browsers. You’ll learn how to design your API so that clients won’t break when you change the data elements in a response or introduce new workflows in the application. You’ll learn how to code both client and servers to allow for change over time – evolvability. And you can do it without abandoning your favorite programming language, framework or library. Based on Amundsen’s work on Hypermedia Types, this talk includes several code examples and access to live servers where attendees can test their own code.

Silverlight Development with SharePoint 2010 Speaker: Steve Mushkat, Charles Mullins
Abstract: SharePoint 2010 is rapidly becoming the standard for enterprise collaboration. Microsoft added extensive support for Silverlight, and with the Client Object Model has allowed developers to more rapidly build and deploy RIA solutions. In this session we’ll do a quick overview of SharePoint, then crank up Visual Studio 2010 to build out example web parts using the Client Object Model.

IIS7 from the Developer view Speaker: Steve Schofield
Abstract: IIS7 from the Developer view. Microsoft has made IIS 7 much more developer friendly along with ASP.NET integration. In this session,, Steve will cover topics including how to use Failed Request tracing, URL Rewrite 2.0 extensibility. Steve will also cover other modules including IIS Express, additional frameworks and happenings in the IIS community!

Data Visualization: Pictures, Not 1000 Rows Speaker: Dave Leininger
Abstract: The number of data point produced by the enterprise is growing at a hockey-stick rate. In this session, we will explore ways to represent complex data relationships through maps and imagery, leading to the development of dashboards and applications that expose realities which are quite difficult to analyze as rows and columns of raw data. SQL Server spatial data features and open data sources are used to demonstrate the development process that results in mobile dashboards.

Eulering up your coding skills Speaker: Matthew Groves
Abstract: According to many experts, "Deliberate practice" is the key to becoming an expert software craftsman. While code-katas & koans are great ways to practice, this session will look at Project Euler (pronounced "oiler"), which has been around since 2001 as a challenging and fun way to hone your coding skills by solving a variety of math, cryptography, parsing, and just plain fun problems, no matter what language you use. We'll look at writing a Euler framework, refactoring strategies, and some of the more interesting problems in Project Euler.

Introduction to Android Development Speaker: Jason Farrell
Abstract: Since its inception in 2009 Android’s growth has been rapid. As one of the first truly open source mobile operating systems Android (by Google) has taken the world by storm and put all of its competitors on notice as it takes on the stalwarts of the mobile arena with its bevy of features and open methodology that gives manufactures an option over more restrictive platforms, such as iOS by Apple. Many leading research firms predict that, by the end of 2012, Android will be the #2 operating system in the world behind Nokia Symbian. This presentation focuses on understanding Android, its pros, its cons and how it can help developers build modern phone applications to compete with iPhone and other mobile operating systems. We will cover the four main versions of Android released to date (Cupcake, Donut, Éclair, and Froyo) as well as those not yet released (Gingerbread, Honeycomb). Where are they heading and what does it take for developers to get up and running developing and deploying applications for the platform.

Designing Application Protocols for TCP/IP Speaker: Stephen Cleary
Abstract: The .NET framwork comes with many great communications libraries, such as WCF. These libraries are excellent when communicating with other.NET applications, and they also work well when communicating with non-.NET applications which have good library support. However, many languages do not have the benefit of such powerful libraries; when wehave to integrate with these types of applications, the common denominator chosen is usually TCP/IP. This session will cover TCP/IP application protocol design.

First, we'll clear up some common misconceptions about TCP/IP,determining exactly what TCP/IP takes care of and what it does not. Next, we'll look at writing the application specification itself, including tips on choosing a port and protocol versioning. The two "big lessons" follow this introduction: how to preserve message boundaries (using message framing) and how to detect dropped connections (using keepalives).

Finally, we'll consider everything necessary to implement "XML over TCP/IP", which is a common request for this type of integration scenario. The phrase "XML over TCP/IP" is a good executive summary, but we'll cover everything necessary to actually make it work. Time permitting, we'll also have an overview of the Socket class API,pointing out pitfalls along the way.

Intro to Windows Phone 7 Application Development Speaker: Jonathan Tower
Abstract: Get a overview of all the basic information you'll need to start developing Windows Phone 7 applications today. To get the most out of the session, it would help to have some basic understanding of WPF or Silverlight, but it is not required.

Introduction to Odata Speaker: Chris Woodruff
Abstract: The Open Data Protocol (OData) is an open protocol for sharing data. It provides a way to break down data silos and increase the shared value of data by creating an ecosystem in which data consumers can interoperate with data producers in a way that is far more powerful than currently possible, enabling more applications to make sense of a broader set of data. Every producer and consumer of data that participates in this ecosystem increases its overall value. OData is consistent with the way the Web works – it makes a deep commitment to URIs for resource identification and commits to an HTTP-based, uniform interface for interacting with those resources (just like the Web). This commitment to core Web principles allows OData to enable a new level of data integration and interoperability across a broad range of clients, servers, services, and tools. OData is released under the Open Specification Promise to allow anyone to freely interoperate with OData implementations. In this talk Chris will provide an in depth knowledge to this protocol, how to consume a OData service and finally how to implement an OData service on Windows using the WCF Data Services product.

Visual Studio 2010 for Architects Speaker: Jennifer Marsman
Abstract: Have you ever had to work with a legacy codebase? Designing new functionality on existing applications can be daunting. There are always differences between the original design and the current implementation. The new Architecture tools within Visual Studio 2010 help you to understand the application you have, design new functionality you need, and validate that your design and your implementation do not deviate. Join us for a look at the new code visualization, UML, and architectural validation tools which allow you to model domain-specific problem domains and maintain proper control and visibility of your software systems.