Unhandled Exceptions

11 Aug

St. Louis Day of .NET–That’s a Wrap!


Earlier this year I I was lucky enough to have been invited to speak at last weekend’s St. Louis Day of .NET conference in (you guessed it!) St. Louis, Missouri Smile.  Held in the Ameristar Resort and Casino, this 2-day event drew nearly 800 attendees from the surrounding Midwest region.

From what I was told, apparently buried somewhere deep in the bowels of this massive hotel, shopping, conference center, and casino complex there actually still is a real riverboat.  As I understand the laws governing legalized gambling on the Missouri river, the boat no longer actually needs to be able to leave port, but it apparently does still require both working engines (that are fired up once or twice a year to prove that they still work) and a riverboat captain aboard at all times.  I’m not sure my ego would permit me to take the job of “Captain of a Boat that Never Leaves Port”, but without even looking into it I can bet that the pay and the benefits for commanding such a stalwart craft probably equate to a pretty good salary for anyone willing to surrender their dream of being a Riverboat Captain in anything but name only.

This whole ‘gaming the system’ thing reminds me of when the zoning laws only permit “renovations” rather than new construction and so people purchase an existing home, raze it to the ground but leave a small corner of the foundation, and then “renovate” the thing into a brand new building.  No matter how well rules are written, I guess someone will find a way to bend them that still complies with the letter of the law, if not the spirit Sad smile.  Kudos to the lawyers involved, I guess!

Overall Conference Impressions

Large~St._Charles,_MO~Conference_Center_Theater_StyleSt. Louis Day of .NET (STLDODN) was a great conference – the local community organizers should really be pleased with the professional manner in which they and the volunteers delivered this conference.  This was the fourth annual convening of this conference and the organizing team really seems to have this refined to a solid, repeatable process by this point.  From the POV of a speaker, I had no complaints whatsoever.  The A/V equipment was top-notch (and overseen by experts in this area), the rooms were all well-planned and organized, and even as a speaker from outside the local region I felt welcomed and included in the social fabric of the conference.  As one of the organizers of the NYC CodeCamp (BTW, call for speakers is still open until 9/11/2011 on that!), I know all too well the effort required to pull off an event like this and so I offer my sincere appreciation for the contributions of all concerned.

I had a really great time and I hope that I’ll be asked back again next year for the fifth anniversary of this stellar event!

First Talk: Taming Your Dependencies with Inversion of Control Containers

My first talk was delivered right after lunch on the first day.  Despite the usual malaise that sets in for attendees after a meal, the crowd of about 120+ seemed awake and interested in what I had to say.  The level of questions and comments suggested that attendees were well-engaged in the content and that it was properly resonating with them.  At the close of this talk, I received what I would honestly consider to be the highest praise I think I could ever hope for in the form of this comment from an attendee:

I have tried several times to understand this topic and always gave up after reading 1-2 confusing blog posts I’d found on it.  This talk laid out everything for me in a way that was really easy for me to follow and comprehend — you have a great way of making complex concepts simple, understandable, and approachable.

I can only hope that others that attended this talk had anything even close to that experience Smile.  As of the date of this blog post, I’ve received 9 ratings resulting in a 4.67 average (out of 5.0) so at least for the disappointingly tiny number of attendees that bothered to rate the talk, it seems they were very satisfied with it.  BTW, if you were there and haven’t yet rated the talk, please do so ASAP right here so that I can get the broadest feedback possible in re: how to improve this talk for the future.

If you’re interested in reviewing the content from this talk, it can be downloaded here:

Second Talk: Refactoring to a SOLID Foundation

This second talk was scheduled for 8:00am on the second day of the 2-day conference and so my own expectations for attendance were pretty low.  I was extremely pleasantly surprised to see that over 100+ came out to hear it even this early in the morning after a long night of hard drinking socializing!  In speaking with the organizers, the choice of this time-slot for this talk became clear: the other 8:00am slots were all allocated for what STLDODN calls “JumpStart” talks, introductory talks designed to get one started with a specific technology/framework (e.g., JQuery Jumpstart, ASP.NET MVC Jumpstart).  By slotting my talk against those designed as more intro content, pretty much everyone awake at that hour and not interested in intro content would end up in my session Smile.  Pretty smart, actually (and seemed to work well, ensuring that I had a really full room for the talk)!

This talk went pretty well and the audience seemed awake, alert, and engaged despite the early hour for it.  Several people offered that having a patterns talk first thing in the morning really kicked off their day right and  got their brain in the proper state of mind to enjoy the rest of the day.

In order to fit what’s otherwise a 1.5 hour talk into the 1.0 hour time-slot I had to do two things:

  1. remove one of the (semi-)gratuitous refactorings from the code demo
  2. shut up and code

#1 was easy to do and based on feedback I don’t think it negatively impacted the quality of the talk or the audience’s ability to follow along, but #2 was harder than I expected Open-mouthed smile.    Nonetheless, I did manage to complete this talk in almost exactly the hour allotted for it.  The feedback was almost universally positive on this talk and I always enjoy delivering it to an audience like this one that’s receptive to learning about how design flexibility into a codebase without inventing a gigantic configuration subsystem with thousands of knobs and levers.

As of the writing of this post, this talk has rec’d only five ratings, but all five gave me 5.0 (out of 5.0) so at least among those bothering to respond I have to consider this talk a success.  If you were there but haven’t yet rated this talk, please do so here ASAP – otherwise you are robbing myself and the STLDODN organizers of important metrics that can help guide our future actions.

If you’re interested in reviewing the content from this talk, it can be downloaded here:

Third Talk: Unit Testing Patterns and Anti-Patterns

This last talk of mine was delivered just before lunch on Day Two to an audience of about 100+.  Its always great to see a Unit Testing talk gather an audience that large – I’m seeing this more and more at .NET-centric events but I’m old enough to remember that it wasn’t all that long ago that such topics were considered ‘fringe’ and garnered only meager attendance in most cases.  The trend is certainly encouraging to me as a proponent of testing as a way to know my code actually works (vs. the type-and-pray approach favored by others Smile ).

This talk was a bit of a mixed-bad in re: its delivery.  In response to comments from prior deliveries of this talk that there wasn’t enough time for code samples, I reduced the amount of time spent on the slide portion of the talk to give us more time to look at the code + tests in the IDE.  This did help the problem, but there still wasn’t time to dig into nearly as much of the code as I would have liked for this talk.  I can blame part of this on trying to cram a 1.5 hour talk into the 1.0 hour time-slots at STLDODN, but I knew about this time-limit going in and just did a less-effective job of time management for this talk than the other two I delivered.

Issues with time-management are a recurring theme for deliveries of this talk and I think part of the challenge here is that its conceived of as a talk that involves audience participation (“Who can tell me what’s wrong with this test?”) and that approach is always a double-edged sword – it helps to ensure the audience is engaged, but it also slows down our progress through the code in unpredictable ways.  I probably really need to seriously consider having TWO versions of the code for this talk in the future: one for non-time-boxed user group settings where I can afford to “go interactive” with the audience and one for time-boxed conference settings where its probably more important to try to cover all of the code samples than it is to engage the audience directly during the test-refactoring process.

Agile says “Introspect and find ways to improve for the future” and so I think this is definitely a change that I need to make for future deliveries of this talk in order to better manage my time.

The good news is that despite my (fairly obviously) running short of time, the content that I did manage to cover in the talk seems to have been well-received.  As of the date of this blog post, this talk has received an average of 4.78 (out of 5.0) from the nine people who took the time to rate it.  If you were at this talk and didn’t yet rate it, please take the time to do so here if you have a minute.  All comments, good or bad, are encouraged!

If you’re interested in reviewing the content from this talk, it can be downloaded here:

Thanks Again to the Telerik Insiders Program

telerikLogo-web-174x69pxI would be completely remiss if I didn’t take this opportunity to thank Telerik for making it possible for me to attend and speak at STLDODN this year.  Through my association with their Telerik Insiders Program, they provided funding for my travel and lodging expenses, without which I probably would not have been able to make this trip.  If you want to thank Telerik for making such things possible, feel free to contact them and let then know how much you appreciate their continued efforts in helping to support this kind of community event and speakers such as myself!

08 Aug

CMAP: Intro to Agile Principles, Practices, and Processes – that’s a Wrap!


At the beginning of this month I had the pleasure of traveling down to Columbia, Maryland to address the August 2011 meeting of the Central Maryland Association of .NET Professionals (CMAP).  I delivered my talk Introduction to Agile Principles, Practices, and Processes which involves no code whatsoever but focuses in on understanding the differences between Agile and Traditional approaches to managing software engineering projects.

This meeting had a pretty good turn-out, with about 35-40 in attendance.  Despite their being no code, it looked to me as if most everyone remained alert and engaged during the talk’s 1.5 hour delivery.  I fielded some great questions from the audience (always a good indicator of people paying attention!) and we had some good discussions about some of the challenges facing Agile adoption.

The CMAP user group itself was very professional in its organization and execution, complete with laptop-based electronic sign-in and thermal-printed nametags for all (including myself as the speaker).  One of the things that really impressed me was the degree to which the group spent time at the beginning of the meeting announcing other area events and user group meetings – this really went a long way to helping to cement the idea of community around the meeting (“We’re all in this profession together so let’s help each other out.”).

After the meeting, another 10+ of us reconvened at a local watering hole to continue the conversations – thanks for inviting me down and for having me out for drinks following; I really enjoyed the conversations and the discussions, both during and after the meeting~!


The slide deck for this talk can be downloaded right here if you’re interested in seeing a copy for yourself.

telerikLogo-web-174x69pxThanks again to the Telerik Insiders Program

As part of my participation in the Telerik Insiders Program, Telerik funded my travel costs to make the drive down to the user group and deliver the talk.  Telerik deserves a big thanks for their efforts in working to increase the effective reach of speakers such as myself and its been a pleasure for me to have the opportunity to visit local software development communities in larger regions than just NYC through my continued association with Telerik.

10 Jul

My Upcoming Michigan Speaking Tour

imageI’m in the process of putting the finishing touches on several talks that I will be giving the week of July 18, 2011 in the southern part of the state of Michigan.

Thanks to the combined financial support of the INETA Regional Speakers Program and the Telerik Insiders Program, I can afford to make the trip to visit user groups in Detroit, Lansing, and Grand Rapids later this month!

My Michigan Schedule

Tuesday July 19, 2011: West Michigan .NET User Group

On Tuesday evening, I’ll be delivering my Refactoring to a S.O.L.I.D. Foundation talk for the West Michigan .NET User Group in Grand Rapids.  If you’re in the Grand Rapids area, I’d love to have you come out and join us and your fellow developers in the community for the talk!

Wednesday July 20, 2011: Great Lakes Area .NET User Group

On Wednesday evening, I’ll be again (re)delivering the same Refactoring to a S.O.L.I.D. Foundation talk for the Great Lakes Area .NET User Group in the Greater Detroit area. If you’re in the Detroit area, I’d love to have you come out and join us and your fellow developers in the community for the talk!  And if you’re some kind of a weird S.O.L.I.D. groupie come see the talk again tonight even if you were just at the talk in Grand Rapids the night before! Smile (kidding!)

Thursday July 21, 2011: Greater Lansing .NET User Group

On Thursday evening I will be delivering my Introduction to Agile Principles, Practices, and Processes talk to the Greater Lansing .NET User Group in Lansing, MI.  If you’re in the Lansing area, I’d love to have you come out and join us and your fellow developers in the community for the talk!

The Last Time I Saw Michigan…

imageSomewhat humorously, the last time I was in the state of Michigan was over 20 years ago when I was an undergraduate at The Ohio State University and came to cheer against the University of Michigan Wolverines in what we in Ohio always called “the annual scrimmage between two teams from Ohio” (owing to the fact that usually a significant percentage of the Wolverines’ Team was made up of residents of Ohio) but whose official name is of course “the Ohio State-Michigan game at the end of the Big Ten College Football Season”.  FWIW, I’m pretty sure that the Buckeyes soundly trounced the Wolverines that cold November day, but I’m hoping the folks I see in Michigan in another week don’t still hold a grudge against me over that.  Disappointingly, some of them probably weren’t even born when I was last in Michigan so they wouldn’t be able to hold a grudge anyway!

imageThe last time I visited the Great Lakes State I’m pretty sure that I was wearing a shirt much like this one on the left, but rest assured I won’t be bringing it with me on this trip so that I can avoid getting the shit beat out of me in the parking lot as I’m leaving the user groups each night Smile.

Of course, with the recent news on the moral and ethical collapse of the Ohio State University football program, I suspect that the Wolverines have a bit more to laugh about these days than the Buckeyes (and now I probably need to get me a brand new shirt that reads “The Fuckeyes Bucked Themselves” Sad smile).

09 Jul

KCDC2011–That’s a Wrap!

KCDC2011_Closing_SessionOn Saturday June 25th, 2011 I had the pleasure of speaking at my first Kansas City Developer Conference (KCDC) event.  This is the third year that this event has been held and by all accounts it has grown ever-larger each subsequent year.  This year’s event had over 230+ attendees and seemed a great success (seen here is a photo of the closing ceremonies).

The event was held at a perfectly-suited facility, the Regnier Center building on the Overland Park, KS campus of the  Johnson County Community College.  Every time I attend one of these conference-style events elsewhere in the country, I am continuously impressed with the level of facilities that are available to host such things.  One of the constant challenges we face in organizing the NYC CodeCamp is that space in Manhattan is at such a premium that its very difficult to find space to accommodate large groups.  I’m repeatedly envious of some of the facilities that are available for such events elsewhere in the country, and the JCCC spaces for KCDC were certainly no exception.

The organizers of this event did a stellar job – as both a speaker and an attendee, the event appeared to me to have come off without a hitch.  As an organizer of the NYC CodeCamp, I know that no event goes off without some problems, but what separates the men from the boys in this kind of thing is whether anyone other than the organizers is ever aware of what’s gone wrong and what’s being done to fix it in a mad chaotic scramble.

I never noticed a thing going wrong so that’s my measure of successful event-planning!


imageThere are lots of conference-style events in the world, “Why KCDC?”, one might ask.

A few years ago, I had the opportunity to spend some time at the MVP Summit with Lee Brandt, who is one of the organizing team members for KCDC.  At the time, Lee and I were two of a rapidly-dwindling breed: Microsoft Solutions Architect MVPs.

The Solutions Architect category has since been (disappointingly and misguidedly IMO) removed from the MVP program entirely and as existing award terms for Solutions Architect MVPs were expiring back then, existing awardees were being considered for (re)awards in different categories.

This put people like Lee and myself into a bizarre kind of Ten-Little-Indians situation where we were all being ‘picked off’ one by one as our MVP award terms were expiring.  The result of which was that there were precious few remaining Solutions Architect MVPs at that year’s summit so Lee and I were forced to get to know each other Smile.

Lee had a standing invite for me to submit some talks for KCDC and this year the schedules all seemed to align in a way that permitted me to accept his offer to deliver two separate talks at the event.

Telerik Insiders Program to the Rescue!

telerikLogo-web-122x48pxBut with talks accepted for the event, how to fund my travel costs?

I enjoy publicly speaking and sharing what I know with the rest of the world as much as the next guy, but its obviously cheaper for me to get from NYC to Boston or Philly (or even Washington DC) than it is for me to get to Kansas City.  Fortunately, Telerik has a way to help with that problem: the Telerik Insiders program.

About two months ago, I was fortunate enough to have been accepted into the Telerik Insiders program.  Their website does a much better job of describing the program than I can, so here’s an excerpt…

The Telerik Insiders Program is an independent speakers program for the developer community. The group is made up of exceptional, passionate speakers interested in contributing to a bigger cause – educating the community in their free time. These elite speakers travel to user group meetings, code camps and other community driven events alike to deliver sessions on cutting edge technology. Sponsored by Telerik, they are provided with new opportunities to speak on their preferred topics and assistance with travel and logistics.

Sounds like exactly the ticket I’d need to help fund my trip to KCDC – and it was!

Telerik is really to be commended to their efforts in this area of assisting with the travel costs for community speakers such as myself –with their support, I was able to make the trip to KCDC and help represent the public face of Telerik’s support of the .NET developer community.

Without their assistance, I literally would not have been able to make this trip and contribute to this event, so if you want to thank them directly for funding my ability to participate, send Emily Parker a friendly thank-you e-mail (but don’t tell her that Steve sent you Smile).

Domain Driven Design Implementation Patterns in .NET

imageMy first talk was Domain Driven Design Implementation Patterns in .NET.  I’ve delivered this talk several times at user groups in the past but never in the context of an event like KCDC.  The real reason for this is that the talk always takes more than 2+ hours to deliver and so the only real way it could ever work at a conference-style event is as a half-day seminar or at least a pair of back-to-back 1+ hour session slots.

I admit to being somewhat surprised that KCDC accepted this talk and did just that: booked it into two back-to-back one-hour time slots to give me the time needed to deliver the content.  In my experience, very few conference organizers seem willing to gamble on content that takes more than ~1 hour to deliver and the KCDC organizers deserve real kudos for their being willing to do so with this talk.  Hopefully, the success it was met with will encourage them to do so again in the future and perhaps even serve to make other conferences consider doing the same sometimes when the content warrants it.

FWIW, I’m grateful that this talk was assigned the first two slots of the day so that both myself and the attendees had enough energy to make it through the whole thing Smile.

In addition to my surprise that this session was accepted at a conference at all, there were two other things that really surprised me about this session…

The first was that when I asked for a show of hands about the attendees familiarity with DDD concepts, only about 5 attendees raised their hands.  Usually this talk is attended by people with at least a passing familiarity with most of the concepts of DDD.  Fortunately, the talk doesn’t actually assume familiarity with DDD and so it was possible for me to spend a bit more time on some foundational concepts (slides for which I always have at the front of the deck for just such occasions!) before digging into the code.

That first surprise made the second surprise even more curious to me: the 40-seat room was packed into standing-room-only, with people sitting in the aisles and standing in the hall outside the doorways!  Chairs had to be brought in from adjacent classrooms to seat everyone and by the end I think the attendance was closer to 50-60 (though I admit to not making a hard head-count of my own).  The large turn-out seemed very peculiar to me when you intersect that with the first surprise about the attendees’ relatively low level of familiarity with DDD in the first place.

I’m honestly not certain what the attraction was for so many to attend this talk.  Whether it was myself as an out-of-town speaker making people extra curious, attendees’ interest in what a 2+ hour session might be able to offer, or emblematic of an increased interest in the entire area of DDD among .NET conference attendees I honestly cannot say.  But I am intensely curious as to why this session was so unexpectedly popular.  At a minimum, it encourages me to consider submitting it to more conferences with similar attendee demographics.

The good news, both for myself as a speaker and for the attendees that came to the session, seems to be that the talk was very well received (nearly all 5s across the board and few 4.8s thrown in to keep me humble Winking smile).

All kidding aside, I got a lot of extremely positive comments both for the content of the talk and its delivery, making me feel very good about the effort I put into it.  Its grueling to deliver a 2+ hour ‘performance’ like that, but so long as the feedback tells me that attendees got good value for their time, I feel that it was worth the hard work!

Thanks again to those who attended this talk and to those that offered constructive feedback about how to improve it in future deliveries.

If you attended this session at KCDC and have not yet done so, I would really appreciate your rating and providing comments on this talk.

As always, the slides and code samples can be downloaded for reference.

Unit Testing Patterns and Anti-Patterns

imageMy second talk of the day (though with the 2-session talk in the morning it felt like my third!) was Unit Testing Patterns and Anti-Patterns.

I’ve also delivered this talk in several past user groups and events and its usually very well attended and this delivery was no exception.  There were perhaps 50-60 attendees in this session and despite the mid-afternoon time-slot for this talk, it appeared to me that they were alert and engaged and interactive the whole time!

I barely had enough time to get my laptop booted up and connected to the projector before the session started – I was engaged in a complex discussion with some attendees in the central hall area and only barely noticed that my session was about to start!  Note to self: SET AN ALARM ON YOUR PHONE FOR 10 MINS BEFORE YOUR SESSION STARTS NEXT TIME, YOU IDIOT! Smile

Despite that slight hiccup in getting started (sorry, folks – rookie mistake that I admit being a bit embarrassed having made after all the talks I’ve delivered!), we got started just about a minute late and were still able to plow through the material in the time allotted.

Feedback for this talk was also almost uniformly positive, garnering me ratings of 4.5 and above by nearly all attendees.  As with any talk, I’m much less concerned with my ratings for my sake than I am in using them as a measure of whether the attendees got value out of the talk for their time or not and so I consider these ratings a good indication that I probably wasn’t wasting anyone’s time with this content!

Thanks again to those who attended this talk and to those that offered constructive feedback about how to improve it in future deliveries.

If you attended this session at KCDC and have not yet done so, I would appreciate your rating and providing comment on this talk.

As always, the slides and code samples can be downloaded for reference.

Whither KCDC2012? Smile

imageI had a really great time both speaking and attending KCDC2011 and hope to be asked back by the organizers again for next year!  To those of you who extended your hospitality to me during my brief visit I just want to say a bit THANKS – you really made the trip enjoyable for me!

And to those attendees who offered me feedback on my sessions, challenged my assertions in public or private, or otherwise took the time to share your input and experiences with me, I also want to say a big THANKS to you as well – when I attend conferences you will rarely if ever find me spending time in the ‘Speakers Lounge’ because the real value to me in participating in such events is in interacting with the attendees before, during, and after my talk(s).  Those of you that engaged with me helped make the trip worth my while too and for that I’m both thankful and looking forward to the possibility of seeing you at next year’s KCDC if you’ll all welcome me back again!

01 Jul

CQRS: Crack for Architecture Addicts –That’s a Wrap!

imageLast Thursday (6/23/2011) I had the privilege of delivering my new talk, “CQRS: Crack for Architecture Addicts or an Idea Whose Time Has Come?” to the Philadelphia-area ALT.NET user group.  This was my first delivery of this new talk in my repertoire and overall I think it was pretty well received (at least based on the feedback from attendees that night).  For whatever reason, Philly ALT.NET has become a sort of a test-bed for some of my new talks – about 18 months ago the Philly ALT.NET group was venue in which I first delivered my “Domain Driven Design Implementation Patterns in .NET” talk in its single-session format (prior to that I had only delivered it as two separate talks, the first talk all theory and concepts and the second talk almost all code).

imagePerhaps there’s something about Philly ALT.NET that makes me want to experiment with new content…or maybe its just that I can high-tail it out of there to drive back to NYC afterwards so if a new talk is a complete failure I can safely head for the hills and avoid the mob of pitchfork-wielding developers demanding my head on a pike if my talk sucks Smile.

All kidding aside, I’m not really certain just exactly why I seem to have a history of testing new content on Philly ALT.NET, but in a sense they benefit from my willingness to experiment with them.

Man, Can I Talk for A Looooong Time!

Since this was a completely new talk for me, I’d not really had any past experience with how long it would take to deliver this content.  But one thing that I did know for certain was that with 50+ slides there was no way it was going to fit into an hour Smile.  I’d rehearsed the delivery of the content (both the slides and the code walk-through) beforehand and came up with about 2 hours for the talk.  When you folded in Q+A both during and after the content, it ended up taking about 2.5-3 hours to deliver the talk.

This is (of course) significantly longer than most (all?) user group presentations and it almost entirely rules it out as a talk that could ever be delivered at any event with a pre-defined time-slot (i.e., CodeCamps, etc.) unless 2 back-to-back session slots were allocated for it but if you’re in the mood for what is basically almost a half-day seminar on CQRS, then this talk might be for you!

This is in fact the very same problem with the aforementioned Domain Driven Design Implementation Patterns in .NET talk – its just infeasible to try to fit it into anything shorter than about 2.5 hours.  To the credit of most of the attendees, nearly all of them stuck with me until the bitter end (9:30pm or so!) so I’m not quite ready to conclude that the talk is too long, just that its longer than a ‘typical’ talk.  I suppose that after sitting through my 3-hour Domain Driven Design Implementation Patterns in .NET talk and now this one, Philly ALT.NET attendees are probably starting to understand that asking me to come speak means surrendering about 3 hours of your life to learning about new things Smile.  I’m probably starting to be known down in that area as “the 3-hour talk guy”, but I suppose that so long as that’s also “the 3-hour valuable content guy”, I think I can live with the reputation.  Fortunately, the comments I received from attendees seem to imply that they got a lot of value out of the talk and weren’t disappointed by losing three hours of their lives, so I’m thinking that on balance this talk was a success.

Beta Presentation: Room For Improvement

imageI began the talk by telling the room that this presentation is still very much a work-in-progress.  Of course, I like to think that every time I deliver a talk I learn about something else that can be tweaked to improve the next delivery of the same content, but in the case of this being the first delivery, things were much more in flux than for a talk I may have given multiple times prior.  Overall, the feedback was very positive, but there were also some comments that pointed out areas for improvement.

One comment that I took to heart was that the content is too front-loaded with slides and back-loaded with code.  Anyone who has seen most of my talks knows that I usually prefer to flip back and forth between slides and code during the entirety of my presentation rather than the often more common approach of “all slides up front followed by all code at the end”.  I find its more engaging (and effective!) for the audience to see slides that introduce a concept and then flip to explore code that demonstrates the concept in practice before returning to the slides to introduce the next concept.

With this talk, I abandoned that tried-and-true approach of intermingling code with slides and went with all-slides-up-front followed by all-code-at-the-end.  My reasoning for this was that I felt strongly that there were enough new concepts to introduce with CQRS that it would be important to lay a solid foundation of understanding them in their entirety before trying to fully grok parts of a code sample.  I still feel this to be a challenge with explaining CQRS to audiences, but I’m not convinced that solving it as I did here by massively front-loading the presentation with slides is really the right answer.

As developers, we are probably hard-wired to want to see code ASAP and I think that too many concepts introduced before we see this code probably risks losing our interest and our focus (though I give the Philly ALT.NET audience big props for sticking it out with me as we plugged through the 50+ slides up front!).  I definitely need to rethink a way to have a sample with small subsets of the code that we can explore to reinforce each of the concepts as they are explained rather than trying to ramp up on all the concepts and then exploring a comprehensive sample that demonstrates all of the concepts at once.  Its pretty clear to me that my present choice of ‘CQRS Sample App’ probably isn’t the right choice to show people individual discrete CQRS concepts one at a time so this is an area where I feel I probably need to rethink things a bit in re: what I use as my sample as we move through the slides.

Live and learn – the Agile tenet of Continuous Introspection and Improvement is alive and well in this process!

Slides, Code, and other References

For those interested in the slides from this talk, they can be downloaded here.

The links in the final reference slide (which also include the code sample(s) used in the talk) are reproduced here for convenience:

Central Hub for All Things CQRS: http://www.cqrsinfo.com

Udi Dahan’s on CQRS (et. al.): http://www.udidahan.com/2009/12/09/clarified-cqrs/

Simple CQRS Sample Application: https://github.com/gregoryyoung/m-r

Comprehensive CQRS Sample Application: https://github.com/MarkNijhof/Fohjin

Jonathan Oliver’s Post on his Event Store project: http://blog.jonathanoliver.com/2010/07/cqrs-event-store/

Rinat Abdulluin on Getting Started with CQRS: http://abdullin.com/cqrs/

Greg Young on Testing Your Domain Using Events (video): http://skillsmatter.com/podcast/design-architecture/talk-from-greg-young

As mentioned, if you attended this talk and have constructive feedback to offer, I’d be very appreciative if you visited http://spkr8.com/t/7876 and provided a rating, comments, or both!

And if you’re going to be in the area, I am scheduled to (re)deliver this same presentation several times:

I’d love to see you there at one of these events if you’re interested in the content but missed the Philly ALT.NET meeting (but bring a comfortable chair since it’s a 2+ hour talk!)

27 Nov

D.C. Alt.NET Presentation–That’s a Wrap!

imageAbout a week and a half ago I had the pleasure of traveling down to Washington DC to deliver my Domain Driven Design Implementation Patterns in .NET  talk to the Washington DC area ALT.NET User Group.  About 30-40 people showed up for the talk, held at the offices of The Motely Fool in Alexandria just over the river from Washington DC.

Matt Podwysocki, who helps to organize the group along with several other DC-area software engineers, has been after me to come down there for some time and so I eventually managed to find an open slot in my schedule to make the trip.  Since my mother still lives in Bethesda, MD just north of the District, it was relatively painless for me to make the trip down from NYC, remaining overnight at my mother’s before heading back the following day.

Still Timing Issues

There are still some timing issues with this presentation (e.g., it takes a pretty long time to crunch through the material) as detailed previously here and here.  But by making sure that I spent a bit less time expounding on each of the core DDD concepts than in past deliveries, I was able to reduce the delivery of the content to about 2.5 hours from its past deliveries of between 3 and 3.5.  We started right after pizza at about 7:00pm and wrapped up about 9:30pm after a Q+A session on the topics.

Great Engagement

The audience was really well-engaged and involved in the discussions during the delivery of the material, offering some great points, challenging some of my suggestions, and offering input into other alternate ways to approach some of the issues that the presentation focused in on.  Its really great to deliver a talk to an interactive and engaging audience since this is how I come to learn as well and I got some great feedback and input from the group this time too.

Based on the feedback I received and the comments following the talk, it seems as if the attendees got good value out of the content and enjoyed the presentation.  I had several people approach me afterwards and mention that this talk really helped crystalize for them a better understanding of DDD in a concrete and valuable way that they felt they could take back to their daily work to make good use of.

Pub Talk

After the talk, a number of us headed out to a local hotel bar for some great follow-on conversation and discussion.  One of the things I really enjoy about traveling to speak to user groups in other areas is the opportunity to interact with the attendees in informal discussions and the DC ALT.NET group didn’t fail to provide this same opportunity.  Thanks to everyone who came out for the talk and listened intently during the long delivery, asking probing and challenging questions all the while.  Thanks also to those that then came out for some conversation and accompanying hydration after the fact too Smile.  I had a great time and hope that DC ALT.NET did as well – thanks for having me down for the talk!

Code and Slides Downloads

If you’re interested in the slides or the code samples from the talk, they can be downloaded from the following links…

26 Nov

Agile Firestarter NYC Autumn 2010–That’s a Wrap!

imageAbout two weeks ago, on November 13th, 2010 we finished the (re)delivery of the Agile Firestarter content here in NYC to an assembled group of about 80 interested software developers.  This is now the fourth delivery of this content, including two prior Agile Firestarters in NYC and one in nearby New Jersey.  The team involved has varied slightly over the various deliveries but for this one I was joined by Dan Berlin, Erik Stepp, Mark Pollack (my co-worker at SpringSource), and Alex Hung (who, as usual, captured the sessions on video in his usual style for those unable to attend).

I delivered two talks at the event, the first an overview of Agile concepts and principles to kick off the day and the second a (re)delivery of my Refactoring to a S.O.L.I.D. Foundation talk.  Unfortunately, these two talks ran back-to-back, meaning that the attendees were probably long-since tired of hearing my voice after the first three hours of the morning — I know I was sure tired of speaking by that point! Smile

Success! (?)

By most accounts, the event was a success – people seemed to get great value out of the content and provided us organizers with great feedback on what they liked and what they didn’t (which we will fold into our planning for the next event, as usual).  Hopefully the event helped to introduce another 80 people or so to the concepts, principles, and practices at the heart of Agile software development.  The event included (as usual) a mix of lecture-style content and lab exercises for the attendees, offering them both the opportunity to gather information and to apply that knowledge in group collaboration situations.

IIS + XP –> Max 10 http Connections!

We did have a few little hiccups in the delivery of the event this time.  Our attempts to make the starter code for the lab exercises and the PDF files of the slides available to attendees via an ad hoc WiFi network ran into some technical difficulties – while we *did* size the DHCP addresses for the WiFi network property, we failed to remember that IIS on Windows XP (the OS that we just happened to have on the laptop we arbitrarily chose to host the files) limited concurrent connections to no more than 10 at a time Sad smile.

Oops!  Fortunately, a last-minute real-time download/install of light-weight OSS webserver enabled us to get the downloads back on track for the attendees.

Topic Coverage Challenges

Some of the feedback indicated that people wanted more information provided about many of the topics we presented at the event.  Some of this is to be expected, given that we are introducing many often-foreign concepts to people in the course of the eight hour day.  But some of this is probably in direct response to tweaks we chose to make in the schedule and content of the sessions based on feedback from past deliveries of the content.

While the overall list of topics has remained relatively fixed over the course of the four deliveries of the Agile Firestarter event, after each event we have requested (and received) feedback from attendees that has lead us to make modifications to the time-slots and depth of each of the topics.  Invariably, those topics for which we have chosen to reduce the time allotted based on past comments receive “wish you could go into more depth on this” comments the next time.  For this Firestarter, the Continuous Integration topic seemed to take the brunt of this criticism.  In the past events, the CI talk included a demonstration of a working CI server.  For this event, we chose instead to go with screenshots for CI to reduce the timeslot a bit to make room for more depth in other topics.  Not unsurprisingly, this lead to the comment “wish CI had included a demo” Smile

Win some, lose some I suppose – everything in life is a series of trade-offs and I like to think that we tried to make the right choices…but of course we will take this feedback into consideration as we plan the agenda for the next Agile Firestarter and so we’ll probably at least consider (re)adding the demo to the CI talk again next time.  Its all a giant feedback loop and we try to learn what we can from each delivery of the content, continually refining it as best we can in each iteration, remaining true to the fundamental spirit of continuous learning at the root of Agile.

Missing Downloads

Most of the slides and code samples were provided to attendees during the event, but afterwards we realized that the code samples for my Refactoring to a S.O.L.I.D. Foundation talk weren’t provided in the ZIP file that was distributed to attendees via the WiFi at the event.  In case anyone wants them or is curious, here are both the slides and the code samples from that talk:

Agile Campfire Event in Spring 2011

Just as we have in the past, its likely that we’ll be planning a follow-on Agile Campfire event designed specifically for past attendees of the Agile Firestarter events where attendees will get to spend an entire day working in a team setting to develop an actual working software solution along with other attendees and a dedicated agile coach to help direct their efforts.  Look for more info on this event as it approaches, but rest assured that all Agile Firestarter attendees will be emailed to let them know about the upcoming Agile Campfire event, so stay tuned for more information~!

‘Til then, happing coding~!

26 Nov

NJDOTNET User Group–That’s a Wrap!

On November 11th, 2010 I had the pleasure of being asked to deliver my talk on Domain Driven Design Implementation Patterns in .NET to the Central NJ .NET User Group at the Infragistics offices in Cranberry, NJ.  The talk started at 6:30pm and lasted until nearly 10:00pm – more of a free half-day of training and less of a user group talk Smile.

Thanks to those 30+/- folks who stuck it out until the bitter end.  Much to the credit of the attendees, only a very few of the meeting attendees had to leave before the talk was completed.  I’m pretty certain that *I* didn’t want the talk to last 3.5 hours – I doubt most of the attendees did either, but I can assume that the level of interest, feedback, and participation of the attendees remaining high the entire time must have meant that people were getting good value out of the talk!

A Recurring Problem: Timing and Content Challenges

Delivering this talk for a user group presents an interesting challenge – its designed to be delivered as a 1.5 hour talk about considerations for implementing various DDD patterns in .NET but its heavily dependent on an important underlying assumption: that the audience is already familiar with DDD concepts and principles.  Often the audience that tends to show up for this talk has a mixed experience with DDD – some are familiar with the concepts, others have heard of it, still more are actively trying to practice DDD, and still others are unfamiliar with the details of most of the concepts.  This makes is hard to deliver the talk “as planned” because to do so usually means that some segment of the audience won’t really get the full value out fo the talk without my taking time to introduce some DDD “background” that explains most of the concepts.

I initially ran into this problem when I delivered this talk in February for the Philly ALT.NET user group.  In that talk, I found that I had to back up a bit and provide some DDD context before proceeding to the code itself.  Fortunately, I happened to have a DDD Concepts presentation on hand for that talk and was able to quickly pull it out and run through it to provide the needed background to the attendees before delivering the originally planned presentation.

I’ve since learned from that experience and have restructured the overall presentation to be more of a combination of concepts and code rather than the code-centric talk for which it was initially conceived.  But front-loading the code-centric content with a primer on DDD Concepts and Theory tends to increase the overall length of the talk significantly.  Fortunately, it seemed most of the NJDOTNET attendees were more than willing to sit through the entire length of the talk, despite its length.

From my quick perusal of the reviews I received from the attendees, it seems the talk went over well and people were able to get good value from the content so despite its length it seems people were able to remain engaged and interested in the topic.  Based on the questions and discussion, it seems that a lot of the attendees were interested in the subject matter – its really great to see people latching onto the DDD concepts and working through some of the decision-points in deciding how to codify their domain knowledge in their software solutions.

Downloads and Samples

In case you missed the talk (or were in attendance and would like to review the code samples, etc.), here are both the slides and code for download:


26 Nov

Fairfield Westchester Code Camp–That’s a Wrap!

Code Camp Wrap Up

Three weeks ago (on November 6th, 2010), I had the good fortune of being selected to deliver two talks at the recent Fairfield Westchester Code Camp (FWCC) in Stamford, Connecticut.  Even though its about equidistant from my house as the Philadelphia Code Camp, I’ve not prior considered participating in FWCC because it always seemed conceptually too far away to make a day trip out of.  When I accidentally stumbled into the role of helping to organize the 2010 NYC Code Camp in the early part of this year, I came to know and work closely with Mark Freedman who, along with others from the area also organizes the FWCC event.  So when word reached me of the next FWCC event being scheduled, I determined to submit several talks for the event, hoping that I would be selected to participate.  Fortunately, two of my talks were chosen:

  • Unit Testing Patterns and Anti-Patterns
  • Taming Your Dependencies with Inversion-of-Control Containers

Both of these were repeats of talks I’d previously delivered in other venues.  The Unit Testing talk had been most-recently delivered at the Philly Code Camp in October of this year and the IoC talk had been delivered prior for the venerable NotAtPDC2009 online event that shadowed the PDC event last November.  For each of these, I spent some time polishing the content and updating it a bit as well as rehearsing the live-coding examples that accompany each of the talks but the process served to remind me how much easier it is to (re)deliver talks from prior content vs. creating new presentations from scratch Smile

Taming Your Dependencies with Inversion-of-Control Containers

This presentation begins with my explaining that the goal of the talk isn’t to create IoC Ninjas out of the audience but to introduce the basics of Dependency Injection and Inversion of Control and to discuss the value of the techniques and the role that IoC containers play in reassembling collaborating classes to accomplish meaningful work.  As part of explaining these core concepts, I rely heavily on using the LEGO block metaphor to relate to the decomposition and reassembly of components in code.

After a bit of refactoring our existing code sample to introduce dependency injection, we look at some techniques for manually injecting dependencies and then move on to understanding how an IoC container can assist in this process of reassembly.  To finish things off, we take a very brief look at how IoC containers can be used with Aspect-Oriented-Programming (AOP) approached to introduce so-called cross-cutting-concerns in your applications.

The feedback from my delivery of this talk was almost universally positive.  In addition to written reviews received afterwards from evaluation forms, I also was approached by several people immediately afterwards who offered their thanks for my presenting what had previously seemed like a complex and challenging set of topics in a form that they could easily understand and in a manner than suggested several real-world scenarios in which they could begin to apply the principles I discussed.  In a sense “thanks to your presentation, I finally ‘got it’ ” is perhaps the best thing an attendee could tell me about my efforts – it clearly shows that I was able to reach at least some of the people in the room Smile

I’m pretty certain that the delivery of this session was captured on video so once I know more about where this is available for download, I will update this post to reflect that.  I the mean time, here’s links for the slides and the sample code for download:

Unit Testing Patterns and Anti-Patterns

I also delivered my Unit Testing Patterns and Anti-Patterns talk for the second time (the first being at the Philly Code Camp referenced above) and for the most part this was a successful session as well.  The room wasn’t quite as packed as it had been for the Philly Code Camp delivery but it was a good crowd, engaged and offering good feedback and commentary.  This talk is more of an interactive conversation with the audience rather than a straightforward lecture and so its success (or not) is heavily dependent on the audience’s willingness to engage.  For the most part, the audience offered good input and helped move the discussion along.

The slides and sample code are available for download here:

Thanks for the Speaker Dinner!

Speaker Dinner

The photo at left was taken at the Speaker’s Dinner, held at a local ale house after the event.  Unfortunately, it’s the only photo of the event that I have to share, but it captures the part of these events that I (secretly) value the most – the opportunity to interact face-to-face with other smart people in the .NET ecosystem, share ideas, and argue opinions.

Often times, such events even provide opportunities to meet people that I’ve interacted with online many times but haven’t had a chance to meet in person.  Although he’s turned away from the camera, on the left hand side of the table is George Mauer who lives in New Orleans but (unbeknownst to me) happens to have family in the NYC area.  He managed to time a visit to see his family with FWCC and so I got to meet someone I’ve “spoken to” online many times but who (normally) lives over 1,300 miles away!  Code Camp networking FTW!

I’m also joined at the table by Dane Morgridge, John Zablocki, Ned Ames and others.  John Baird and Greg Shackles are there too (both off camera to the left).

I understand that Telerik had something to do with sponsoring the Speaker’s Dinner, so it wouldn’t be fair to enjoy the meal without offering a shout-out to them in exchange for their funding a very enjoyable evening of food, drink, and great conversation.

I’ve no idea when the next FWCC is scheduled, but hopefully I’ll get the chance to come back and give more talks again next time; I had a blast at this one~!

15 Oct

Entity Framework 4 Firestarter: That’s a Wrap!


This post is a bit overdue, slightly out of chronological order, and will probably have me rambling a bit too much but I’ve been busy lately – so sue me :)

Earlier this year I was was asked if I wanted to participate in delivering the Entity Framework Firestarter event here in NYC.  I eagerly said YES and the planning began in late summer between myself, Julie Lerman and Rachel Appel.

Julie is the well-known author of the recently-released definitive work on Entity Framework 4, Programming Entity Framework, 2nd Edition.  Kudos to Julie for having the intellectual honesty to at least call her second book on EF “2nd Edition” instead of calling it “4th Edition” to correlate with EF4!  The picture provided at left is that of Julie delivering her (much more substantial and in-depth than mine) part of the day’s content on Entity Framework.

Rachel Appel is one of our Microsoft Developer Evangelists here in the NYC region and was instrumental in organizing the event, coordinating getting someone as well-known as Julie to speak about EF with myself, and also delivered a session at the event herself too.

The videos for the event will (eventually) be made available on MSDN Channel 9 but the slides are already available here.

Its The End of The World!

What’s that, you say?  The guy who swears by NHibernate as the best choice for ORM tools delivering talks introducing people to Entity Framework?  How can that be?  What’s next –?  Hell freezing over?  Dogs and Cats living together?  Flying Pigs?

Well, not quite…

The Importance of Speaking from Knowledge

While the internet and other media outlets seem intent on exponentially increasing the number of people enabled to criticize things which they haven’t taken the time to even try to understand, my own personal opinion is that about the only thing less valuable than opinion in uninformed opinion.  People who form opinions without bothering to do the hard work of investigation are a recurring pet peeve of mine.  So when it came to something like Entity Framework, I was determined that I was not going to be speaking from an uninformed point of view but wanted to really understand for myself the changes that Microsoft had made to EF since their initial release.

I was determined that I wanted to be able to speak about EF from a position of knowledge rather than one of ignorance.  But like just about everyone else out there, my time is short and (usually) over-booked so I needed a kick-in-the-pants to force me to learn EF4.  Volunteering to speak at this Firestarter event was that kick-in-the-pants for me – it provided me with a concrete time-frame within which I had to learn EF in sufficient depth that I could speak about it publicly without coming off as a complete moron (I suppose the reviews for my sessions will let me know if I was successful at this or not!).

And having access to someone like Julie with her unbelievable wealth of knowledge about EF4 to provide a safety-net for my learning was an opportunity almost too good to pass up.  When you have that rare chance to learn something new with the assistance of someone who is clearly an acknowledged master in the subject, you take it!

.NET Community, Meet ORM

Like it or not, the vast majority of the Microsoft developer ecosystem is populated by people who largely feel that until Microsoft expresses interest in an aspect of software development, its not worth their time to investigate or explore it.  We can complain about this all we want, but the honest truth is that this is probably an aspect to the Microsoft developer ecosystem unlikely to change any time soon.  Choosing to live and work within this environment means learning to deal with this element.  Not to like it of course, but just to acknowledge it and work with it.

That could mean that the right reaction is to throw one’s hands up in frustration and abandon the platform and the ecosystem as some have done (and I expect more to continue to do for these reasons and others).  But it could also mean that when Microsoft (even belatedly and kicking and screaming in many ways) eventually awakens itself to an area of software or technology somehow completely new to them but largely ubiquitous elsewhere, you need to try to seize that opportunity and make something of it.  Microsoft has now belatedly come to terms with what much of the rest of the software development world has long known: many, many data access problems are indeed best solved with some sort of object-relational mapping approach.  Entity Framework is the manifestation of that acknowledgement on Microsoft’s part (now that they’ve dropped the silly charade that “EF isn’t an ORM, but its something that you might use to build an ORM”, of course) :)

Just as with Unity when it came to IoC containers, MSTest when it came to unit testing frameworks, the REST starter kit for WCF when it came to REST, ASP.NET MVC when it came to (relative) sanity versus complexity in web application frameworks, and many more cases, Entity Framework isn’t a groundbreaking exploration into exciting new areas of these technology categories.  But that’s ok – when your customer base is near-totally dominated by Enterprise customers (and that’s where vast amounts of your revenue is derived), “trailblazing technologies” isn’t what you want to be known for.  Trailblazing scares big enterprises and scaring your customers isn’t a recipe for success – its a recipe for failure.  For Microsoft to do more trailblazing work would really require (among other things) a shift in its hierarchy of revenue – not something likely to happen any time soon.

But nonetheless, “where Microsoft goes in the .NET ecosystem, so goes the majority of developer mindshare” (like it or not) and so when Microsoft produces one of these things while they tend to never be the pinnacle of their category, they do have the indirect effect of ‘blessing’ each specific category of these technologies.

If Microsoft not having an entry in any one of these fields permits the lazy among us to explain away their ignorance of a technology, then it must follow that when Microsoft does enter one of these technology areas it tends to act as a verification to .NET developers that they need to begin to pay attention.

Unity did this for IoC containers; blog posts, podcasts, MSDN Magazine articles and more had to at least take the time to explain what IoC was and why you should care.  MSTest increased awareness of unit testing among .NET developers.  And Entity Framework increased awareness about ORM.  In a very real sense, this is the application of Kennedy’s phrase “A rising tide lifts all boats”.  To be sure, some developers won’t ever look beyond the Microsoft offerings in these categories.  But as awareness of these areas increases, an ever-larger number of .NET developers will begin to explore other offerings in these same categories.  And that helps everyone grow.

Technology is about more than Technology

But being introduced to a new developer technology needs to be about more than just learning an API.  It needs to be about learning the patterns of (successful) implementation that go along with a new technology.  Its possible to pick up EF, use the provided incredibly heavy-weight code-generation tools to produce partial classes that are intimately coupled to EF and know everything about their own dirty state, erroneously call these things ‘domain objects’, serialize them and transmit them between tiers in your application, and claim “I’m done”.  But in the end, just about every one of these things that EF makes ‘easy’ to do is a demonstrable anti-pattern in ORM techniques that just about every other software development community has long-since discovered and largely agreed are bad ideas to pursue.

If you take EF “out of the box” and do any or all of these things, its critically important to understand that just as when you follow other anti-patterns its not as though a lightning bolt will come from above and kill you dead.  But the reason that something is considered an anti-patterns is that it has been shown, again and again, to be a common approach to solving a particular software development challenge that results in repeated pain for you at later points down the road.

These effective patterns and ineffective anti-patterns in re: ORM are already well-established: value persistence-ignorance in your domain model, resist transmitting your domain model over the wire between tiers in your application, consider code-gen to be a last-resort rather than a quick-jump-start for your own code, and many more.  Somehow these patterns and anti-patterns need to get into the hands of EF adopters that are both ignorant of the EF API but also ignorant of the best (and worst) practices when it comes to using and ORM.

Because EF (unfortunately) tends to enable more of these anti-patterns than encouraging many of these patterns, its important for potential adopters to be exposed to the patterns and begin to understand them.  Its only through this process that enough people will begin to demand enough change to EF that it stands a chance of maturing as an ORM to the point where its possible to use it out of the box in a way that won’t kill all but the most trivial of projects.

The last session of the day for which Julie and I co-presented, Writing Testable/Maintainable Apps with EF,  demonstrated some of the ways in which its possible to abstract away your code’s direct dependence on EF and yet still gain most if not all of the benefits of EF in your projects.  And in the process this approach enables you to unit test your way around EF as well as ensure that your solutions remain easier to maintain and extend over time.  In essence, this session was an attempt to share some of the ORM patterns with the group rather than just demonstrating out-of-the-box anti-patterns with EF.

And since so very few .NET developers have significant experience with EF, they are effectively blank slates upon which we can either sit idly by as anti-patterns are imprinted upon them or we can take action to try to help them understand the patterns and why they should care about respecting them.

Its The End of the World (as we know it)

So I look at Entity Framework as an opportunity to increase awareness among developers about both ORM technology and effective ORM patterns.  Do I think EF is the best ORM tool out there for .NET?  Of course not :)  But do I think that increasing awareness of ORM concepts via EF will lead to increasing numbers of people seeking out more mature ORM frameworks?  You bet I do.

And the huge growth in the NHibernate download statistics each month since the release of Entity Framework 1.0 prove it.  And that’s why while EF has helped bring about the end of the world as we know it (the majority of .NET developers having no idea what ORM is), its hardly the end of the world in its entirety that I’m interested in trying to influence how most .NET developers approach their consumption of ORM in general and Entity Framework in particular.

© 2014 Unhandled Exceptions | Entries (RSS) and Comments (RSS)

GPS Reviews and news from GPS Gazettewordpress logo