Stephen Bohlen


Currently a Principal Software Engineer for the Technology, Evangelism, and Development (TED) Team within Microsoft Corporation, Stephen brings his varied 20-plus-years of experience as a former practicing Architect, CAD Manager, IT Technologist, Software Engineer, CTO, and consultant to assist select Microsoft Partner organizations in their adoption of cutting-edge and pre-release Microsoft developer products and technologies.

Stephen is also an active contributor to several Open-Source Software projects including NHibernate, Spring.NET, Common.Logging, NDbUnit, Common.Logging, and others.

Active in the software development community, Stephen speaks publicly, blogs (semi-)regularly, and is the author of several popular screencast series focused on Agile and ALT.NET concepts and technologies including the widely-praised 15-part Summer of NHibernate video series introducing viewers to the popular open-source O/RM tool.  Stephen is also a founding/organizing member of the NYC ALT.NET user group as well as a co-organizer of the New York City Domain Driven Design User Group.  For the past several years, he has been the Chairperson of the annual New York City Code Camp event.  He has also been a Microsoft MVP award recipient in Solution Architecture, ASP.NET, and Visual C#, a member of the ASP Insiders and the Visual C# Insiders, and formerly held the office of the Vice President for INETA, North America.

7-Minute Apps: Tools and Techniques for Rapid App-Development on Windows and WindowsPhone

Sunday, June 22nd, 2014 at 10:30 am

Unless you’ve been living under a rock for the past five years, you know that the arrival of ‘apps’ had fundamentally changed the world of software development both for the better and for the worse! In this talk, we’ll explore the wide-variety of tools and technologies that are available to support RAD App-Development on both Windows and WindowsPhone (HINT: its easier than you think to build apps!).

We’ll take a whirl-wind tour through the tools that are available to developers today to spin-up full-features apps in a fraction of the time most developers expect. We’ll start by looking briefly at traditional app-building approaches so that we all understand the overall mechanics of the process, then we’ll investigate the tools available to radically shorten this development process. We’ll investigate techniques to leverage existing responsive web design content to build full-featured hybrid web apps for both Windows and WindowsPhone based on your existing web sites as well as exploring App Studio which enables developers to build native apps in no more than just a few quick mouse-clicks. We’ll also take a look at the wide range of services and API integration tools that make it dirt-simple to integrate rich public APIs into your apps (e.g., Facebook, Twitter, demographic data, and more).

Lastly, we’ll dig into the various considerations that play into the business factors that developers have to consider when developing apps (HINT: almost everything you think you know about the business of software is WRONG). Attendees will leave this session both with a comprehensive understanding of the options available to them to build rapidly apps for the Microsoft platform with a minimum of effort as well as the business considerations that need to inform their thinking as they design their apps.

Panel: Year of the Developer

Saturday, June 21st, 2014 at 4:30 pm

Refactoring to a S.O.L.I.D. Foundation

Saturday, June 21st, 2014 at 1:30 pm

In this session we take a small, functional but tightly-coupled, software solution and improve its design using each of Robert C. Martin’s S.O.L.I.D. principles as follows:

  • SRP: Single Responsibility Principle
  • OCP: Open-Close Principle
  • LSP: Liskov Substitution Principle
  • ISP: Interface Segregation Principle
  • DIP: Dependency Inversion Principle

Each principle is applied in sequence to the existing solution, making it possible for the attendee to observe the principle in relative isolation first while also evolving an understanding of how the principles all collaboratively reinforce each other when applied together.

Before each principle is applied and the solution is refactored to introduce it, the attendee is presented with one or two simple PowerPoint slides to introduce the concept and provide some abstract understanding of its goals and benefits to OO programming. The principle is then applied to the existing solution, demonstrating the practical application of the principle to working software.

At each step along the way, the existing solution (a simple console application) is re-executed, demonstrating that the overall behavior of the software solution has not been negatively impacted by the various refactorings.

Exploring Domain Driven Design Implementation Patterns in .NET

Saturday, November 17th, 2012 at 1:40 pm

Domain Driven Design (DDD) is a pattern language developed by Eric Evans for effectively managing complexity in software solutions. DDD has evolved as an approach for conceptualizing your project’s problem-space but as software developers we are also keenly interested in translating those DDD patterns to code. If you have always wanted to know how to get started with using DDD in your projects then this is the talk for you — offering both an intro to DDD concepts as well as a look at NET implementations of DDD concepts.

In this talk we will first begin with a brief introduction to DDD concepts and principles for those new to this overall approach and then explore various implementation patterns to translate DDD concepts into .NET code. We will investigate implementations for Repositories, Specifications, Entities, Value Objects, Services, and other DDD constructs. We will also discuss some considerations for how to structure your projects and solutions to maximize flexibility and manage the evolution of your domain over time. This discussion will focus less on offering prescriptive guidance and more on helping the attendee understand some of the potential trade-offs that alternate implementation approaches can provide.

Refactoring to a SOLID Foundation

Saturday, October 6th, 2012 at 2:05 pm

In this session we take a small, functional but tightly-coupled, software solution and improve its design using each of Robert C. Martin’s S.O.L.I.D. principles as follows: SRP: Single Responsibility Principle; OCP: Open-Close Principle; LSP: Liskov Substitution Principle; ISP: Interface Segregation Principle; DIP: Dependency Inversion Principle. Each principle is applied in sequence to the existing solution, making it possible for the attendee to observe the principle in relative isolation first while also evolving an understanding of how the principles all collaboratively reinforce each other when applied together. Before each principle is applied and the solution is refactored to introduce it, the attendee is presented with one or two simple PowerPoint slides to introduce the concept and provide some abstract understanding of its goals and benefits to OO programming. The principle is then applied to the existing solution, demonstrating the practical application of the principle to working software. At each step along the way, the existing solution (a simple console application) is re-executed, demonstrating that the overall behavior of the software solution has not been negatively impacted by the various refactorings.

Adding .NET Generics to your C# Recipes; Demystifying Lambdas: A Lot More Than Just LINQ

Saturday, October 6th, 2012 at 9:55 am

When .NET introduced Generics, they were largely used in the Base Class Library to support strongly-typed collections. But Generics also open the door to a richer vocabulary for us to use to express our intent in code. In this session we will explore the multitude of uses for .NET Generic Types beyond collections including creating more flexible class declarations and method signatures as well as understanding the role of generic type constraints.

When .NET 3.5 ushered in the age of the lambda expression for C#, the most visible use-case for this language feature was in support of Language-integrated-Query (more commonly known as “LINQ”). But lambdas also offer us the opportunity to be much more succinct in our coding of many common C# constructs. From events to delegates to anonymous methods, closures, and more, lambdas offer us the opportunity to say more with less in a fundamentally different way than we’ve previously considered using C#. In this talk we will explore both the underlying principles behind lambda expressions and several of the ways that we can drastically improve our code by leveraging this new functional-style paradigm in .NET.

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.

Refactoring to a SOLID Foundation

Saturday, March 17th, 2012 at 1:45 pm

In this session we take a small, functional but tightly-coupled, software solution and improve its design using each of Robert C. Martin’s S.O.L.I.D. principles as follows: SRP: Single Responsibility Principle; OCP: Open-Close Principle; LSP: Liskov Substitution Principle; ISP: Interface Segregation Principle; DIP: Dependency Inversion Principle. Each principle is applied in sequence to the existing solution, making it possible for the attendee to observe the principle in relative isolation first while also evolving an understanding of how the principles all collaboratively reinforce each other when applied together. Before each principle is applied and the solution is refactored to introduce it, the attendee is presented with one or two simple PowerPoint slides to introduce the concept and provide some abstract understanding of its goals and benefits to OO programming. The principle is then applied to the existing solution, demonstrating the practical application of the principle to working software. At each step along the way, the existing solution (a simple console application) is re-executed, demonstrating that the overall behavior of the software solution has not been negatively impacted by the various refactorings.

Demystifying Lambdas: A Lot More Than Just LINQ

Saturday, March 17th, 2012 at 10:20 am

When .NET 3.5 ushered in the age of the lambda expression for C#, the most visible use-case for this language feature was in support of Language-integrated-Query (more commonly known as “LINQ”). But lambdas also offer us the opportunity to be much more succinct in our coding of many common C# constructs. From events to delegates to anonymous methods, closures, and more, lambdas offer us the opportunity to say more with less in a fundamentally different way than we’ve previously considered using C#. In this talk we will explore both the underlying principles behind lambda expressions and several of the ways that we can drastically improve our code by leveraging this new functional-style paradigm in .NET.

Adding .NET Generics to your C# Recipes

Saturday, March 17th, 2012 at 9:55 am

When .NET introduced Generics, they were largely used in the Base Class Library to support strongly-typed collections. But Generics also open the door to a richer vocabulary for us to use to express our intent in code. In this session we will explore the multitude of uses for .NET Generic Types beyond collections including creating more flexible class declarations and method signatures as well as understanding the role of generic type constraints.