How do you do data access in your ASP.NET web applications? The number of choices can be staggering: ADO.NET, Entity Framework, Massive, Dapper, etc. etc. etc. Even when you chose a technology, what kind of architecture pattern will you use for the highest flexibility and lowest amount of friction?

In this presentation, Mike will show you a tried-and-true data access strategy. He’ll focus on using the NHibernate ORM with the Repository Pattern to create a powerful data access layer. He’ll use an Inversion of Control tool to decouple our data access from the rest of our application. He’ll show tips and tricks on how to create highly optimized database queries.

When we’re done, you should be able to set up a simple Repository Pattern on your own, and you’ll have an example ASP.NET MVC project that you can use to try to become a data access guru!

Mike Cole is a .NET Developer and aspiring software craftsman working at Far Reach Technologies in Cedar Falls. He is the president of the local CVINETA user group and is actively involved in the community. He is a diehard Hawks fan and a fairweather Vikings fan (at least he’s honest). He enjoys hunting, video games, technology, and chasing his toddler around trying to get out what he just stuck in his mouth.

If you plan on attending our meeting on April 2nd, please RSVP.

Exploring Domain Driven Design Implementation Patterns in .NET
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.

This talk 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.

If you plan on attending our meeting on March 5th, please RSVP.

Synopsis
As a developer with years of experience developing web apps using ASP.NET, SQL Server, Windows Server and Active Directory, how do you move to the cloud with Windows Azure? How can you apply your existing skills and experience to developing cloud apps in Windows Azure? In this session, we will take a simple, traditional ASP.NET app and walk through the migration to Windows Azure. We’ll discuss the important considerations, practices, architectural differences, challenges, advantages and economic benefits to consider when migrating to Windows Azure.

If you plan on attending our meeting on February 6th, please RSVP.

Synopsis
.NET has typically been viewed as a Microsoft-only language, but there have been at least two attempts to create a clean room implementation. One of them, the Mono Project, has successfully ported the CLR to other platforms including Linux, Macintosh, Android, and the iPhone. Now, even code compiled in Visual Studio can be used directly on other, non-Microsoft platforms without additional recompilations or processing. However, there are some considerations that need to be taken when writing for multiple platforms.

Our Presenter
Dylan Moonfire has been programming since the early 80′s, starting with C and picking up languages as he went. He’s worked in a number of fields, ranging from telecommunications, financial, insurance, and computerized sewing software. Starting in the 90′s, he started to contribute to open source projects and has contributed and maintained various OSS projects ever since.

If you plan on attending our meeting on January 9th, please RSVP.

The year wouldn’t have been possible without our sponsors. We were lucky this year to have two wonderful full-year sponsors. TEKsystems supplied our meeting room and various representatives attended many of our meetings through the year. Discount ASP.NET sponsored our dinner, allowing us to comfortably have meetings that start quickly after the end of the work day without having to scramble for food. Thanks to you both for your support!

Our group co-sponsored 2 Iowa Code Camps during the year, bringing our flavor of continuous self-improvement to hundreds of developers from around Iowa and surrounding states. This is a significant outreach of our group that continues to see great support within our membership.

2012 is shaping up to be another good year. We are booked for speakers through April, including two that are doing week-long tours through Iowa at various user groups. I’m excited for the coming year and hope you will continue to appreciate the content.

I’d like to see many more short demos of techniques and tools, at least one per meeting. I look to you for that to share what you know and use in your day-to-day work. Let me know if you want to do something or just bring it with you.

Happy holidays and Merry Christmas to you all. See you January 9th!

Greg

If you plan on attending our meeting on December 5th, please RSVP.

Learning LINQ with Practical Examples
We’ll be talking through many of LINQs common operators but we’ll do that by looking at code. In many cases, we’ll look at the imperative “non-linqified” code and work toward making it more readable by rewriting it in a declarative, linq-y way.

Nate is a developer with eleven years of experience, eight of it in .NET. Over those years, he has worked for many different employers in the Corridor area: APAC, Rockwell, Aegon to name a few. He currently works at Integrated DNA Technologies writing WinForms applications used by the business. Nate says: “The thing I’ve learned more than anything else is that I still have so much to learn. I don’t expect that to ever change.”

If you plan on attending our meeting on November 7th, please RSVP.

Chapter 1 started out with the elevator pitch for functional programming: by specifying the “what” instead of the “how,” you end up with more readable, reliable, and maintainable code. From an implementation standpoint, you end up constructing programs by composing expressions instead of series of statements. What is an expression, you might ask? The best definition we could come up with is “something you can assign to a variable,” which seemed to click for everyone.

One of the first questions that came up is also one of the most important while diving into a new programming paradigm: how is this different from any other abstraction? At the end of the day F# and C# both compile down to imperative IL, so what’s the point of this extra complexity? I expect we’ll get a more complete answer as we move through the book, but to start out I tried to argue that it’s simply another approach to abstraction that is often simpler than object-oriented alternatives. For example, the Template Method Pattern is largely unnecessary in functional languages because varying behaviors within an algorithm are just passed into a method as functions instead of implemented in subclasses.

We also discussed the value of having functional libraries at our disposal. In addition to System.Linq, we discussed Jon Skeet’s EduLinq and MoreLinq, as well as System.Interactive (Ix) from Microsoft’s Reactive Extensions project. Most functional introductions use projection and filtering examples, but an example of grouping really seemed to resonate with the group as something that’s complicated enough to find real value in a functional abstraction.

We finished our discussion of Chapter 1 by discussing FP in relation to other object-oriented techniques, which can be summarized in one sentence:

Functional programming is dependency injection one method at a time.

We were short on time, so we breezed through Chapter 2 rather quickly. Which is fine because we’ll see all of this material again throughout the rest of the book. Those topics included:

• Immutable data structures
• Recursion and recursive data structures (F# list)
• Expressions vs statements
• Functions as values and higher-order functions
• Discriminated unions
• Pattern matching
• Units of measure

One point of confusion was the section on “language-oriented programming,” which seemed to suggest that you should use the language to make your program more readable. No kidding! There are certainly opportunities for DSLs and fluent interfaces in a functional context, but I wasn’t quite sold on this point.

So far everyone seems pleased with the book and we’re looking forward to getting into some real code. Next up are Chapters 3 & 4 for Tuesday, October 18th.

Book club is held at Roasters Coffee House in Hiawatha on the third Tuesday of every month at 7pm.

Jon is an IADNUG leader and consultant from West Des Moines, Iowa. He has been programing for the past 15 years and currently infatuated with writing WPF and Silverlight applications. Recently, Jon has created two tools that help .Net Developers write better code – Nitriq Code Analysis and Atomiq Duplicate Code Finder.

If you plan on attending our meeting on October 3rd, please RSVP.