Dec 3
Nothin’ But .NET Training
icon1 Darrell Mozingo | icon2 Reviews | icon4 December 3rd, 2008| icon33 Comments »

When you think about corporate training courses, you pretty much picture a few 8-5 classes with a nice lunch break, generally easy workloads, and a somewhat low learning curve, right? At least that’s what I always knew them to be until last week. After taking J.P. Boodhoo’s Nothin’ But .NET boot camp the week of November 17th in Philadelphia PA, though, that rosy picture of easy days with only a relatively low amount of learning has been replaced with one of intense training and pushing the boundaries of what I thought I was capable of.

Plenty of others have written mini reviews about this latest course, and mine isn’t going to be substantially different. It was an utterly amazing course, plain and simple.

He started us out by sending some prep material a week or so before the class began. Among other things, it included a project with about 18 failing specs (unit tests in behavior driven development terms) that we had to get passing as OO-ish as possible. Simple enough, or so it seemed. I got them all passing in what I thought was a pretty nice solution, at least until the class started.

  • Day 1: 8:30am ~ 11pm. After just abut everyone’s machine was up and running, we talked about some basic design patterns (adapter, decorator, etc) and applied them to the prep exercise together. About mid day JP wrote out a basic fluent interface he wanted for querying and sorting in the exercise and left it to us to implement, then walked us through it together. The end result for the exercise was nowhere near what I came up with before the class and really got me thinking about the way we design applications at work and what we consider “good”. Very cool intro to fluent interfaces though. Didn’t do any TDD that day, as he wanted to focus on some of the fundamentals.
  • Day 2: 9am ~ 11:30pm. We started working on the front controller architecture (a slight twist on the common MVC style you see in Monorail and ASP.NET MVC) for the web store we’d be working on the rest of the week. From here out it was all TDD using JP’s custom testing wrapper framework, which he mentioned he’s working on release publicly soon. We also looked at a basic logging implementation. The way he was able to craft a lot of these tests in a TDD manor really opened my eyes at how to tackle a lot of tough problems I’d hit in the past.
  • Day 3: 9am ~ 1:30am. Pretty much finished up the front controller implementation, which was cool to see as it gave me a tremendously deep understanding into how the bigger .NET MVC frameworks out there work, more than any blog post or series really could. We’d been pairing on and off until this point, but we actually broke into teams later in the day to get the whole front controller working to the point where we could display a page, so team interaction was heavily stressed here.
  • Day 4: 9am ~ 3:30am. Broke off into larger teams to complete the bulk of the web store, including a full end-to-end (database to browser) experience and getting everything configured in a nice, fluent, manor. I worked on a fluent interface for the routing configuration, among other things, and the other guys in my group worked on ones for the ORM, IoC container, and object mapping. There was just so much to do it was mind boggling. It was great running into a problem and having JP come over to explain it in a way that made absolute sense, too. His ability to walk through a problem and get a solution is amazing.
  • Day 5: 9am ~ 2:30am. Went over domain driven design (DDD) using a standard shopping cart scenario in the morning, then finished working in our teams on the store front the rest of the day, tweaking our fluent interfaces and adding features. We didn’t get to where we wanted to, but I think we were all happy with what we came up with. The momentum from the rest of the week really took a beating after lunch, unfortunately, but we plowed through it.

The material we covered in the class alone makes the course worth it, and that’s not even counting the fantastic food we had free of charge all week (steak houses, chinese, subs, full course Italian – all thanks to Brian Donahue), the awesome discussions, both technical and non, with everyone during meals, the screen casts from the week, and the laughs (which there was plenty of!).

You also have to factor in JP’s motivational ability. The passion he has for development was evient from the first day, and never once slowed down. You can tell this guys absolutely loves what he does, and his ability to share that with everyone and have some rub off is truely special. I came away from the class not only with a new found technical outlook on my code base, but a personal & professional outlook on life. Seriously, it did that much. I tried talking JP into a motivational speech circuit, but it didn’t sound too likely 🙂

JP talked how he really wanted everyone to stay in touch after the course ended, even to the point of having an alumni get together later next year. It’s cool how much you get to know these other people in the class after such an intense week. I recommended to JP that he have the future classes work on a social networking site instead of the web storefront during the course. Not only has the whole web storefront sorta been played to death in examples, but it’d give everyone an actual tangible tool to stay in contact after the course ends, knowing they built it.

So, if you have the chance to take this course, even if you have to beg and gravel on your knees for the funds, do it. It’s easily worth every penny and more.

May 20
Cleveland Day of .NET Review
icon1 Darrell Mozingo | icon2 Reviews | icon4 May 20th, 2008| icon33 Comments »

Cleveland Day of .NETI attended the first annual Cleveland Day of .NET this past Saturday, the 17th. Other than a few Microsoft launch-type events, I’ve never attended an actual community get together like this before, so it was a new experience for me.

Do I think it was worth it, in terms of the time (7 AM to 6:30 PM on a Saturday with decent weather) and money (gas for a 100 mile round trip and lunch) invested? Well, lets take a look at each of the six presentations I attended and then at an overview of the whole event:

  1. Why Ruby?Joe O’Brien
    • Joe started off by saying this wouldn’t be a talk about specifics in Ruby or a 100 level intro, and he delivered on that. Instead, he focused on some neat features of Ruby that’d make a seasoned developer want to dabble with it and potentially jump ship. I’ve seen a bit of Ruby glancing through blogs and articles, and even wrote one or two very basic learning applications in it, so I was glad he skipped the syntax basics and instead focused on things such as catching missing methods and then relating that to O/RM and enterprise development uses.Ultimately, I thought this was a great talk. Joe was quite the funny presenter, kept me engaged the whole time, recovered very gracefully from a few presentation hiccups, showed some neat examples, and renewed my appetite for Ruby. It was a nice presentation to start out the day, for sure.
  2. Introduction to Test Driven Development with the ASP.NET MVC FrameworkAlan Stevens
    • Alan began with an intro to the ASP.NET MVC Framework and followed up with a few live coded unit tests. While I liked his presentation style (his excitement for this stuff was contagious), I wasn’t too impressed with the content. It was very solid information, but I had some higher expectations going in, and he only got around to doing basic unit tests to check the rendered view and such things. Nothing really new for me there, unfortunately, but it was still nice to hear the MVC architectural pattern explained from a different point of view.
  3. Software Ninjitsu: Designing for ChangeNate Kohari
    • Focusing on the foundation of object design – cohesion and coupling – then moving onto the basics of Inversion of Control (IoC) using his Dependency Injection (DI) framework, Ninject (which I’ve looked at before and is actually pretty neat), Nate delivered an awesome presentation. Admittedly his first large one, he handled a failing projector halfway through the presentation with ease, and the room was packed with standing room only. He touched briefly on a few other aspects of his framework such as Aspect Oriented Programming (AOP), but he stuck to the basics of IoC very well and presented them, at least I thought, in a very logical fashion. His gratuitous use of ninja references was actually pretty funny (although you couldn’t expect anything less with a session title like that) and was a nice change of pace.The only thing I would have liked to see was some more live code. He stuck to Power Point (or whatever the Mac equivalent he was using was) pretty good, though a bit of Visual Studio and bigger examples might have helped a bit, I think. Overall it was a great presentation though.
  4. Ouch, that hurt! Lessons Learned from an Agile ProjectMichael Eaton
    • I was looking forward to this session the most. My team is currently shifting into a RUP/Agile methodology (and actually had a nice 2 hour discussion on this the Friday before this event), so I asked Michael if I could tape the talk with the hopes of showing it to the rest of my team when I got back to work. It was a good talk, reminding everyone about the major pain points in project management: communication, buy-in, estimating, etc. Some were client specific while some were more common. It spurred some interesting discussion from the crowd though, and Michael’s slide deck was a pretty funny addition. Also, while I could also see where he was coming from in the talk, the fact that he concentrated on one single job as an example, out of the many I’m sure he’s worked on, made parts of the presentation seem like a rant instead being informational.Unfortunately, in the end the presentation wasn’t exactly what I’d thought it’d be. While we did hit a lot of common pain points, to me they weren’t really related to, or caused by, any particular Agile methodology. They were just general issues that most everyone – including my team – has dealt with in the past. Helpful to be sure, but I was looking for issues relating specifically to a flavor of Agile, such as TDD acceptance, short iteration deliverables, pair-programming acceptance, stand-up meeting issues, planning problems, etc.
  5. Data Access with NHibernateLen Smith
    • Len started off with a quick intro to O/RMs in general and why you’d want to use one, then jumped into talking about various aspects of NHibernate interlaced with live code examples. His examples were pretty decent, using unit tests as quick code harnesses to show off various features like batch queries, lazy loading, SQL query inspection, etc. Pretty standard stuff, and I thought he did a good job explaining it, along with answering a few questions that popped up through the session such as the ability to use NHibernate along side current data access code during a transition period (to which Len just suggested rewriting your data layer). Like Nate Kohari’s talk, he used a lot of pirate and ninja references which I thought was pretty cool.
  6. Intro to the IronPython Flying CircusSarah Dutkiewicz
    • Sarah began by making a case for Python then jumping right into some examples of IronPython, using gratuitous amounts of Monty Python references of course (Ni!). She showed a few basic features of Python and IronPython using the interactive command line tool, including how to use those little animated people from the Windows XP first install wizard. She did a really good job presenting a high-level overview of the features, I thought.

There’s a few other presentations that sounded really interesting and I would have loved to see, and in hindsight I should have floated between some of these sessions to get in a little more more material. I’ll have to keep that in mind for next time.

  1. Silverlight in ASP.NET John Stockton
  2. IronRuby, the DLR and Silverlight Carey Payette
  3. A Look at F# Amanda Laucher

Now, as for the event as a whole I’d have to give it a thumbs up. Everyone got a free, decent quality, tee-shirt upon sign-in, which was neat (standard logo + sponsors white tee). They were giving away books in nearly all the sessions for various reasons, and also gave out licenses to some nice software and an XBox 360 at the end, but I didn’t win anything 🙁

I met a few people there from the Akron area, though I wished I would have networked a bit more. As Michael Eaton put in his review, the small hallways and constant moving of hotel staff made it tough to talk to anyone between sessions.

Attending this event has also peaked my interested in presenting on a topic at some point, perhaps starting with one to my co-workers (though I sort of did one on Linq To SQL a while ago). I’d love to have something to present, and the ability to do it, at a future event like this.

Overall I thought the event was well worth the time and money invested (it being free and getting free swag sure helped). I met some nice people and picked up a lot of new information, and I’m looking forward to attending next year.

Too bad Cleveland is the nearest .NET user group, and they usually start at like 6 PM, as I’d love to attend a few of those but scheduling is usually too tuff. That’s why I’d like to get the ball rolling on the CantonALT.NET user group, so we can spark some local discussion and interest.