2012.1


Our first 2012 Code Camp will be held at the Penn State campus in Abington, PA on Saturday, May 12 from 8:30-5:00. Detailed directions are on the Penn State web site.

  • Lots of code, just say no to slides!
  • 8 hours of learning and networking
  • 60 sessions by 60+ speakers (8:30, 10:00, 11:30/12:10, 1:40, 3:10)
  • 12 tracks + Open Spaces Forum
  • 600 seats with tables (laptops welcome)
  • Breakfast, lunch (two groups), and afternoon snack
  • Raffles and prizes after second lunch and closing
  • Booster registration option for charity donations, parties, and prizes
  • Easy parking
  • Convenient hotels (TBD)
  • After hours party (network with speakers and attendees)
  • The official Twitter hash tag will be #phillycc. Use it when you tweet and search it to stay in the know.

A Lap Around SQL Server 2012

Saturday, May 12th, 2012 at 8:30 am
An introduction to the new features in Microsoft’s newest SQL Server release, SQL Server 2012, released in April 2012.

The Legend of Lambda

Saturday, May 12th, 2012 at 8:30 am
Lambda expressions are a powerful feature of C#, one that can be wielded for good or evil. Attend this session for an adventure through the evolution of the C# language, from the depths of the delegate keyword to the expressiveness of the lambda expression. I will show you how anyone can easily learn to wield and empower code with lambda expressions. It’s dangerous to go alone! Take this: =>.

Get on the Bus with MassTransit

Saturday, May 12th, 2012 at 8:30 am
Building complex systems can often be easier when you break them into smaller services, but how do you reduce the complexity of the coordination between the services? In this discussion, we’ll see how you can use an OSS .Net Service Bus, MassTransit, to facilitate building your applications in a distributed architecture.

Running Highly Effective Agile Teams

Saturday, May 12th, 2012 at 8:30 am
Having been a part of Agile, Waterfall, and projects with no SDLC at all. As a consultant in the business of solution delivery I will often have to come onsite and assimilate to the culture of the client. Other times it is our job to realign the culture of the client to a more agile and efficient way of getting things done. In this talk we will cover estimation, accountability, people vs. process, empowering your team while not risking the delivery dates. I will cover how to pair programming and code reviews contrary to common corporate belief actually make teams more productive and result in higher quality code. And yes how testing will make your team all rock stars!

Automating the Cloud

Saturday, May 12th, 2012 at 8:30 am
Start a server in the cloud, deploy some code to it. Easy? But what if you had to do it 500 times? Come meet Chef and find out why deploying apps to hundreds or even thousands of servers in the cloud can be just as simple as deploying to a single local server. Chef is a configuration management tool that makes dealing with all your servers easy. It’s simple to get started on one or a handful of machines and take those same scripts and infrastructure up to much larger deployments. This talk will cover the basics and rationale for automation, then demonstrate how the same scripts that provision a single server can provision many servers. And once those servers are running, modifying the configuration on all of them is as simple as editing a single file.

Windows Azure – From the Ground Up

Saturday, May 12th, 2012 at 10:00 am
It’s time to accept the hype – “the cloud” is a component of applications going forward.  This will be a code-heavy session were we’ll walk through building and deploying a Windows Azure application.  What new tools will you need?  What new skills will you need?  What are the best resources to keep at the end of your mouse?  In this session we’ll discuss all these points and more.  We will see how easy it is to build on existing skillsets to develop an application that takes advantage of several of the services available on the Windows Azure platform.

Intro to LINQ

Saturday, May 12th, 2012 at 10:00 am
LINQ (Language Integrated Query) is one of the best and easiest to use features in .Net. Introduced in C# 3.5, it allows developers to easily query collections of data. What is great is that it allows the same technique/syntax to be used to query objects in memory, databases, xml and other sources. The session will focus on the core principals of LINQ as well as several related language enhancements that make LINQ possible including extension methods, anonymous types, implicitly typed variables, and more.

Modern Software Architecture: Effective Infrastructure

Saturday, May 12th, 2012 at 10:00 am
In my series on Modern Software Architecture to date, we’ve explored the vital non-technology related facets of our discipline, such as process, design and crafting a message that a modern architect must master to be effective. Throughout these sessions the mantra has been ‘No Code!’ giving us a chance to reflect on and refine our practice without the concerns of technology.
With this latest session, Effective Infrastructure, we’ll get back to our roots and finally wallow in the blessed bits. There will be code samples galore! (It is Code Camp after all.) The modern architect is expected to provide essential Process, Design and Technology leadership to an organization or initiative. And in the case of distributed computing and SOA on the Microsoft stack, this means taming the beast that is WCF, preparing it for mass consumption.
In this session I’ll share the tips and techniques I’ve used in large initiatives to quell the concerns of complexity that often surround WCF, making it approachable to developer communities of a broad spectrum of acumen. Far from rudimentary, we will dive directly into the heart of WCF’s powerful extensibility model, reveal the interception base framework as its core, show how it can support AoP and hint at why I believe WCF is a contemporary framework in its own right, perhaps the most powerful of all.

Introduction To The Async Framework

Saturday, May 12th, 2012 at 11:30 am
Asynchronous programing has been available to .Net developers since version 1. It is a technique use to maintain responsiveness of thread and not blocking it while an operation is being performed. Asynchrony preserves responsiveness while synchronous call blocks, until the result is returned. However the current async patterns available to ..net developers makes developer do funny things to your app code. In this session I will introduce the new Async framework available to Windows Phone, Windows 8 and .Net v.Next.

PowerShell for .NET Developers

Saturday, May 12th, 2012 at 11:30 am
Microsoft Most Valuable Professional (MVP) Doug Finke takes us on a deep dive into PowerShell from a developer’s point of view. Doug shows techniques for integrating/debugging PowerShell from and to C# code as well as using PowerShell with a Windows Presentation Foundation (WPF) application. He also addresses using reflection at the command line, object pipelining, and PowerShell’s REPL.

From Command Line to Cloud: Developer Tools for Cloud Agility in Visual Studio 2012

Saturday, May 12th, 2012 at 12:10 pm
Building and maintaining amazing cloud apps requires the right toolkit. Since the dawn of computing, the command line interface has been an integral part of the developer arsenal. In this session, we’ll take a look at how the right cloud technology offers developers innovative capabilities such as dynamic app creation, scaling and patching, all through a command line that can be invoked by hand, in Visual Studio 2012, or by third party systems. We’ll create a 3-tier .NET application in Visual Studio with an ASP.NET website, a WCF service, and a database. Then we’ll build, package, deploy, and scale it in the cloud all from the convenient and familiar Windows command line.

Demystifying Aspect-Oriented Programming: Help — You’ve got Your Aspects in My Objects! (Two Great Tastes that Taste Great Together!)

Saturday, May 12th, 2012 at 1:40 pm
It probably comes as no surprise to anyone with any real-world software development experience that Object-Oriented inheritance modeling can’t cleanly solve every class of problem we face as software engineers. AOP (Aspect-Oriented Programming) provides us with an alternative perspective on our objects and their behaviors that can be leveraged to powerfully and flexibly solve whole classes of recurring software engineering challenges that OO systems routinely face. In this talk we will both illuminate the fundamental principles and patterns of AOP as well as demystify the different available techniques for adding AOP to the design of OO systems in .NET. We’ll explore techniques like compile-time and load-time IL-Weaving, Static and Dynamic Proxying, and others. We’ll also examine several tools and frameworks (both Open-Source/free and commercial options) that make it easier for for the .NET developer to add AOP techniques to their toolbox for their everyday work. Attendees should possess good intermediate C# language skills and understand core OO design principles.

Introduction to CQRS Architecture and Concepts

Saturday, May 12th, 2012 at 1:40 pm
An introductory talk on the CQRS architecture, featuring high level architecture discussion and a quick dip into a simple example project. This is not a comprehensive discussion of the topic, but a starter to help you determine if CQRS is right for you.

Windows Azure + Node.js

Saturday, May 12th, 2012 at 1:40 pm
In December 2011, Windows Azure announced support for running Node.js in the cloud. Node.js is a popular framework for building web applications in JavaScript. Node uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.  We’ll take a quick look at Azure and the tools for using Node.js in it, including the Cloud9 IDE, which provides the first browser-based deployment tool for Windows Azure.

Introduction to Dependency Injection and Inversion of Control

Saturday, May 12th, 2012 at 3:10 pm
Commonly thought to be the domain of the “cool kids” and uber-geek programmers, dependency injection (DI) and inversion of control (IoC) are actually very simple and easy – and something you’re probably doing right now but didn’t know it! In this presentation we’ll take a look at what DI and IoC are, why they’re good things, the problems they solve, and how to grow your very own!

SharePoint and Azure – Better Together

Saturday, May 12th, 2012 at 3:10 pm
Learn how to leverage Azure’s storage features to extend SharePoint’s multimedia capabilities. In this session, we will cover the integration architecture between the two platforms (and not via page viewer web parts!) and walk through the steps on creating the extensibility from SharePoint using .NET with Visual Studio 2010.  Our demonstrations will show you how you can consume Azure data directly from SharePoint.
Lastly, we will offer our thoughts and invite the audience to discuss and brainstorm the opportunities and future of SharePoint and Azure working together.

Middleware in the Cloud

Saturday, May 12th, 2012 at 3:10 pm

Within the Microsoft stack, both EAI and EDI have historically been tackled by BizTalk.  With December ServiceBus CTP we are seeing an early glimpse into how Microsoft envisions these types of integration scenarios being addressed in a Platform as a Service (PaaS) based environment.

Lets play with ServiceBus, EAI and EDI.

Continuous Integration Isn’t Just for Code!

Saturday, May 12th, 2012 at 3:10 pm
Runners find that they can go faster with a lower perceived effort when they exercise in a pack. The same thing happens when coders pair program, and when colleagues gel. What do we need to do to so we can get code out the door sooner? It’s not just continuous code integration–it’s high bandwidth communication! Find out what companies of all sizes, like Comcast (100k employees), ING Direct (2500 employees), and SmarTesting (30 employees) are doing to successfully adopt and improve Agile development! Paraphrasing from Margaret Mead: “never doubt that a small group of thoughtful, committed [employees] can change the [company]”. This talk is based on personal experience as well as the work of Seth Godin, Jim Collins, Christopher McDougall, Dan Mezick, Christopher Ryan, Cacilda Jethá, Katherine Kirk, Daniel Goleman, and others.