This year, I was fortunate enough to attend DevLink for the fourth year in a row. I’m pretty sure 90% of my Conferences posts are recapping prior trips to DevLink. Well, here goes number four, though I’ll try to keep it more succinct than last year.

Sessions

The first session I attended was on Test Driven Development with T-SQL by Philip Japiske. If you just did a double take at that last sentence, then you know how I felt when I first saw it on the session list. I had never heard Philip speak before, but I was honestly worried that a session on TDD with T-SQL would be a trainwreck. I’m happy to say that it was not, in fact, a trainwreck – it was actually a really good session. Philip showed us T.S.T. (the T-SQL Test Tool) which is basically a set of stored procedures that provide the basic assertion libraries you’d expect to see in a unit testing framework. The real gems were assertion calls like Assert.TableEquals. It can still use some work, but if you’ve got any sort of T-SQL sitting around, wrapping some of that in tests could be very useful.

Another session I really enjoyed was on HTML5 with Todd Anglin. Most of the noise regarding HTML5 that I’ve seen has revolved around mobile development, the canvas tag and how it will replace Flash/Silverlight/etc. Todd did a great job of showing us the other parts of HTML5. I had no idea that there were new input tags that were coming (are here? sort of?) like tel, email, etc. Really, that’s all it takes for mobile browsers like Safari to give the different input types (i.e. if an input element with type email gets focus, you’ll get the email input display on the iPhone).

Jim Wooley did a great job showing off the Reactive Framework (Rx). We spoke a little bit last year when I attempted an Open Space session on Event Driven Architecture and he had pointed out Rx then, but I never really had a chance to dig in since then. Honestly, once people really start grokking Rx and applying it in their frameworks, I’ll think we’ll start seeing some big jumps in the way we write code, particularly on the client side. I’m still trying to think of good applications of it on the server side, though Chris Patterson did mention that MassTransit was looking into adding IObservable capabilities…

There was a session on Caliburn by Bryan Hunter on the first day, but the room was packed so I wasn’t able to hear it. I did get to make it to his part 2 talk on the last day, though, and I really enjoyed it. I still love the way Caliburn uses iterators (with yield) to implement coroutines. If you’d like to get a good feel for Caliburn and what it provides, check out Rob Eisenberg’s MiX session.

The last session I attended on Saturday was on IronRuby and Rails with Shay Friedman. I have already been doing some Rails work on the side, so I was familiar with most of it, but I still wanted to support IronRuby, especially considering Jimmy Schementi’s post regarding IronRuby’s future went up the day before Shay’s session. (side note, lest you think IronRuby is dead, it is having almost daily commits to it and it has the potential to flourish even more in the community’s hands)

Open Spaces

I sat in on a open spaces session led up by Alex Robson on RabbitMQ. RabbitMQ is a “highly reliable enterprise messaging system” that is written in Erlang. Think MassTransit or nServiceBus in the .NET community. It was interesting to hear how other messaging frameworks are structured and to also talk about how messaging and event driven architecture change the way applications are built. It was a very fun discussion.

After my relative success last year leading an open spaces discussion on event driven architecture, I decided to talk about something else I’m passionate about: VIM. I entitled the session, “VIM and other Ye Olde Text Editors” (tongue firmly in cheek). I hoped my poor attempt at title humor would draw people to my session. If by people, I can count 2 individuals, then I can say that, yes, it did draw people to my session :-). Brian Sullivan and Mark Haskamp both swung by and we had a good time talking about Vim and Emacs both. My hope in coordinating the session was in sharing the awesomeness of Vim and getting ideas from other Vim users on how they customize and use Vim to the fullest. I didn’t get a lot of tips in that regard, but I did get to show a few people the very well known String Calculator Kata in Python, which should instead be titled String Calculator in Python in Vim. It’s as much of a kata on Vim as it is on Python.

Brandon Satrom kicked off a talk on "What’s good in MVC, what’s missing in MVC.” I really enjoyed this session – there was a lot of push to improve what we’ve got with MVC. We realized that the finished list (which probably could have continued) leaned heavily on the ways to improve MVC, but I commented that I think this is because we’re really enjoying using it and we want it to succeed and move forward.

I sat in on another of Alex Robson’s open space sessions on NoSQL on Saturday. We talked a lot about CouchDB and Cassandra, neither of which I know a lot about. I’ve read up on Mongo quite a bit more, but I’m finding that the document database (and other NoSQL variants of databases) very intriguing. I’m planning on using one of them for some of my Rails projects at some point.

In closing

All in all, I had a great time at the conference. I really enjoyed getting to see a lot of friends, particularly some of those from the Fort Smith area. I used to get to see most of those guys at least at every FSDNUG meeting, but since moving to Memphis, it had been a couple of months since I had seen them.

Here’s to another DevLink next year!

So, it didn’t occur to me until today that I was creating a trilogy here.

If I had thought about it ahead of time, I would’ve given my titles more creative names like “devLink”, “devLink Strikes Back” and “the Return of devLink.” The true test will be to see if the second post is everyone’s favorite.

Oh well. Maybe next year.

Managed Rootkits

The first session I went to on Saturday was an Open Spaces session on Managed Rootkits convened by Bill Sempf.

Before I continue, read that sentence again. Didn’t see it yet? Here’s a hint: Managed Rootkits. You know, managed… as in managed langauges… like .NET. Get your attention yet? It did mine, which is why I showed up! Of course, I expected to be completely lost because, in my mind, rootkits are hard stuff that take a computer genius to find and fix. Surprisingly though, the concept behind managed rootkits is easy.

But first, some background. Bill had attended Defcon which is where he had originally heard about managed rootkits in the first place (note that his post links to a page that includes a demonstration). That’s how the entire session came to be.

So, wanna know how to hack the framework?

First, take mscorlib. (that’s the primary .NET assembly by the way)

Next, take ildasm. (that’s the MSIL Disassembler – the built-in Reflector if you will)

Disassemble mscorlib into IL.

Write your own IL and paste it in the IL you got from disassembling mscorlib.

Find ilasm on your machine. (you guessed it, that’s the .NET Assembler)

Assemble your modified IL into a new mscorlib.

Drop it in the GAC.

You L33T hacker you.

The entire reason this works is because, once an assembly has been installed into the GAC, the framework doesn’t run additional checks to verify that the assembly matches the hash in its strong name. So yeah, strong naming doesn’t protect assemblies.

Once we were all up to speed on the logistics, we discussed if this was, in fact, a zero day exploit. It’s not. Why? Because you still have to have administrative privileges to modify any files in the GAC. As Raymond Chen points out, “if you have full trust, then you can do anything.”

Anyway, it was a very interesting conversation. I made the point that, even if it isn’t a security vulnerability, there is the whole user perception issue. For example, if an assembly that your application uses is modified so that it posts your credit card information out on the internet, network trace tools are going to show that it is your application that is connecting to the internet. If your computer were already infiltrated to the point that someone could modify mscorlib on your machine, though, managed rootkits likely aren’t your biggest concern. Oh well, it sounded like a good argument at the time.

Domain Driven Design

The next session I attended was on Domain Driven Design with Craig Berntson. Here’s the synopsis from his blog:

Domain Driven Design is a way to design and develop enterprise applications so that they are easier to maintain, enhance, and extend. DDD is overkill for many of the applications we develop today, but still has principles that can be applied to most of the apps we write. In this session, you will learn to apply these concepts.

My personal feelings regarding this talk was that he did an excellent job at actually communicating DDD. He contrasted the typical data-driven design for applications to driving the design of the system from the business domain. He also did a good job of explaining it in terms that everyone could understand. It was a very good talk.

Lunch over Open Spaces

Over lunch, I went back to the Open Spaces area to see if there were any sessions going on then. A group of people were all sitting in one area so I assumed it was going to be a great conversation. It certainly was, but it wasn’t a planned session. It wasn’t even technical in nature at times… I remember discussing favorite Family Guy episodes at one point…

Architecting Architectural Stuff

My last session was on Architecting Modern Distributed Applications with Clint Edmonson. He has posted his slides and thoughts on the conference on his blog. He shared a diagram that he had seen at an internal Microsoft presentation that showed the various architectural layers in typical applications and showed how you could use the diagram to help make decisions like self-hosting versus hosted solutions versus moving entirely to the cloud. A comment he made in passing but that I thought had a lot of merit was adding in a ping operation to all of your services so that you can quickly and easily determine the state of what is working and what isn’t. I know hardware almost always has this, but I hadn’t really considered putting it in software. I know, you’ve probably been doing it for years.

Closing Circle

At the end of the day, I went to the Open Spaces closing circle where we went over the week, discussed how we could more effectively publicize Open Spaces to the rest of the conference attendees, and other things related to the conference. I was a jerk and had to leave early, but it was all positive while I was in the room. I’m pretty sure it didn’t erupt or anything after I left :-)

Once again, kudos to John Kellar and team for planning another amazing devLink. If you’re interested in seeing more and better pictures than I’ll ever be able to take, David Giard has posted a link to his pictures on his blog. If you weren’t able to attend this year, go next year.

Yesterday, I blogged about the first day of devLink – today, I’ll continue the recap with, you guessed it, day 2.

The Open Spaces side of devLink started on day two, so that’s where I went. Like last year, Alan Stevens kicked everything off with the opening circle. (if you’re unclear on the Open Spaces concept, I gave it more time in my post from last year)

Convening my first open space session

Last year, I didn’t have the guts to jump out there and provide a topic that I wanted to convene. This year, though, I thought I’d give it a try. So, I threw out Event Driven Architecture using tools like MassTransit or nServiceBus. Of course, when I brought it forward, I only said MassTransit and a few people came up to ask if I was referring to “mass transit” as in buses or trains. I guess I could’ve been more clear in my explanation. My primary purpose in picking this topic was entirely selfish – I hoped that someone would show up who knew more about it and they could do most of the talking!

Let’s just say it didn’t quite work out that way :-)

I still think it went well. I ended up going over the very basics of EDA and MassTransit and having a discussion about how EDA can vastly decrease coupling in applications as well as how it also completely changes the way a system is architected over all. Interestingly enough, Maggie Longshore mentioned that, in embedded software development, messaging was the norm instead of the typical “call a webservice and wait” that is typical of .NET code. I also spoke about the similarities between EDA and UI patterns like the event aggregator. I mentioned Udi Dahan’s domain events post as well. During our discussion, Jim Wooley mentioned Linq to Events (or the Rx Framework) and pointed everyone to an introductory article on the Rx Framework. I’m still trying to wrap my head around that post!

Towards the end, the conversation drifted off into… just about everything else. We spoke about adding scripting functionality to applications (using tools like PowerShell, IronRuby or IronPython). As the convener, it was my role to ensure the conversation stayed on topic, but I was having fun just jumping around to different topics at the end. I think it went well.

jQuery Plugins are cool

Next, I went to an “eyes front” session from Elijah Manor on writing jQuery plugins. He has posted the slides from his presentation on his blog. Having read “the world’s most misunderstood programming language” from Douglas Crockford, I now consider myself somewhat of a JavaScript fanboy so I really enjoyed the talk. My hands-on experience with jQuery has been fairly limited up to this point and really only included using the Lightbox plugin and a few other tools, so the session was an eye opener. Probably one of my favorite parts of the talk was when Elijah shared some must have developer bookmarklets. I had heard of Firebug Lite before, but the jQuery specific bookmarklets were new to me.

Mono is cool, too

After Elijah’s talk, I went to Sarah Dutkiewicz’s talk on cross platform C# using Mono. I’ve been following Mono from a distance for a few years, so it was good to hear Sarah’s talk. After her presentation, we spoke about things like MonoDevelop, Banshee and other open source things. I wasn’t able to keep up entirely because my Mono experience thus far includes opening MonoDevelop and building Hello World, reading Miguel de Icaza’s blog, and listening to the Hanselminutes episode on Mono and Banshee.

// TODO: Add Mono to the list of cool things to look at some day!

Learning Rails in the hallway

On the way back to the Open Spaces room, I ran into a group of people learning Rails from Leon in the hallway. Note that this wasn’t a planned session - it just happened. Two or three people were sitting on a bench in the hall while everyone else was sitting in the floor. Most had laptops, but a few were looking over shoulders. If I can find a picture, I’ll post it – a picture would communicate this a lot better than I can.

UPDATE: thanks to Matt Brewer for providing a link to the above picture of the impromptu Rails learning session with Leon – and thanks to John Kellar for posting it to his Facebook photo album!

Final Open Spaces Session on… I’m not entirely sure

I was convinced that the final session of the day was on distributed source control. Later, I think I heard it was on DSLs (domain specific languages). In either case, it turned into another fun and random conversation.

I’ll finish up the devLink review covering day 3 soon!

I’ve now attended devLink three times, with each time getting progressively better. This year marked the first time for devLink to be split across three days (from Thursday, August 13 through Saturday, August 15). Day one included preconference-like sessions that were longer in length with days two and three more closely resembling prior years. Like last year, this year also included Open Spaces, which ran over days two and three.

Ruby Enlightenment

My first session of devLink was with Leon Gersing covering Ruby-Koans: Path to Ruby Enlightenment. Let me start this way – I have never been to a session that was presented in quite the way that Leon gave this presentation. Let me give my alternate title for this presentation: “Learning Ruby through Pair Programming using Test Driven Development.” It was amazing. The guys at EdgeCase have created an open source library called Ruby Koans. From the project’s README:

The Ruby Koans walk you along the path to enlightenment in order to learn Ruby. The goal is to learn the Ruby language, syntax, structure, and some common functions and libraries. We also teach you culture. Testing is not just something we pay lip service to, but something we live. It is essential in your quest to learn and do great things in the language.

Leon helped everyone get Ruby othat was done, we broke up into pairs and went through the koans. Leon walked around the room and helped whenever someone ran into a question or a problem.

Let me share the first koan with you as an example. Pull up your favorite command prompt and go to the directory where you extracted ruby_koans. Once in that directory, run rake (rake is to ruby as make is to C or as nant/msbuild is to C#/VB.NET).

The rake file changes the directory to the koans directory and then executes the various ruby files in it, which are unit tests. The first test fails in the ./about_basics.rb file on line 10. Here is what that file looks like:

You don’t really even have to know programming to see what you should do here. Just change the false to be true to get your test to pass. Once that is done, move to the next test and so on.

The koans start at the simplest level and then move up to higher levels of complexity to expose you the Ruby language.

Thanks to Leon for sharing this with us and helping to bring us all closer to Ruby enlightenment!

(thanks to the devLink site for the above picture of the Ruby Koans session)

Closures Explained

The next session was with Chris Smith on closures, lambda calculus, and functional programming with both C# and F#. I already had a basic understanding of closures, but I got a lot more from this talk. Surprisingly, lambda calculus’s name is far more complex than the actual concepts that it introduces. Unfortunately, I still can’t read more than half of the F# examples out there. I seriously need to try it out on some personal projects to understand it. Luckily, the ideas behind it are more solid now. Great job Chris!

The Lost Art of Simplicity

The opening keynote was presented by Josh Holmes on the Lost Art of Simplicity. He posted the slides from when he gave his presentation earlier in the year, so I won’t spend a lot of time speaking on it. I do want to share a few thoughts that I got from it, though.

Josh brought up the thinking that a lot of developers have when they see an application or other project: “I could build that in a weekend.” I saw this thinking a lot from people when stackoverflow.com was built. Josh pointed out the disconnect between this and then explaining to our users that a new feature will take eight months.

That sort of hit me in the gut :-)

He’s right, of course – we do this all the time, particularly in “enterprise” development.

Another comment he brought up that was both true and funny at the same time is that we as developers don’t speak human, we speak geek. How right he is.

And now for something completely different…

Lunch boxes do more than carry food

They carry code. Below is a picture that Micky McQuade took of me trying to explain closures of all things to Anthony Ford. My communication skills were lacking at the time, so I decided to try to communicate with code and, seeing as how the lunch box was the closest writing medium I could find, I used it.

The code snippet below is approximately something like:

void Foo()
{
   var x = 5;
   var nums = new List
{ 1, 2, 3 }; nums.ForEach(n => Console.WriteLine(x)); }

I wanted to show how, if the lambda were moved out to its own function, it wouldn’t be able to access the x variable.

If you’ll be in the northwest Arkansas area tomorrow (April 25), be sure to come out for the NWA Code Camp. There will be presentations on everything ranging from LINQ and Silverlight to iPhone development. I’ll be presenting my PowerShell talk one more time as well. If I can count at all, it looks like there will be 15 different speakers total.

I’m looking forward to it!

I told you we had sushi while at DevLink! We're happy in this picture because we all had just had a great dinner :-) (that, and they told us to be goofy for the picture)

Don't expect me to link to MySpace too many times... I think is a first.

Last year, I attended DevLink. It was very well done and so, this year, I’m going again!

This time, though, I’m bringing a full contingent from the Northwest Arkansas region. Well, okay… maybe three people total isn’t a contingent. Certainly not enough to warrant getting a bus! However, I am still looking forward to heading to DevLink with Randy Walker and Michael Johnson.

If you’re going, look me up. See you there!

Here it is, final day wrap up.

The first session of the day was with Glenn Block and Brian Noyes on Composite WPF (the framework formerly known as Prism). You can think of the Composite WPF¹ library as the WPF version of the Composite UI Application Block (CAB), but it really is a lot more than that. Something to note regarding Composite WPF is that they didn’t start with the CAB codebase, but instead began writing their StockTrader reference application and pulled the framework out of their implementation instead of the other way around. The entire framework was written in a TDD manner. Honestly, it really shows, too. I’ve been using the framework on one of my projects at work and it is one of the first examples from Microsoft of a well decoupled (and useful) piece of software that I’ve seen. I’m a huge fan.

The next session was by Dustin Campbell on “Hardcore Reflection.” Of all the sessions I attended, I think this was the one that started at exactly where my knowledge ended and built entirely on what I already knew. In other words, I learned a lot in this session! Dustin covered topics like RuntimeMethodHandlers, reflection-only assembly loading, and DynamicMethods (via IL generation). I had never really looked at anything under System.Reflection.Emit (frankly because it was scary), but it really isn’t all that bad. An interesting note is that DynamicMethods are what the DLR is using for its high performance in languages like IronPython and IronRuby.

After lunch, I stopped and watched a little “Speaker Idol” from the DotNetRocks guys.

Next, I attended a session with Roy Osherove on Design and Testability. I would sum this talk was on how good code design and architecture allow for unit testing, which assists in maintenance because products spend far more time in maintenance than they do in the initial coding phase. (this is where a lot of the RAD ideas fall down - “Look, I’ve got an application written in a day! Look, I’m spending a week debugging this thing because I can’t find anything!”) If you’re unfamiliar with ideas like Dependency Injection, I would encourage you to check them out. If you have code that relies on external dependencies (shared components, services, other classes, whatever), don’t have your code be in charge of creating it. Instead, pass that dependency (the interface, not the actual implementation) in via the constructor. In doing so, your constructor declares everything that it needs in order to run. It also allows you to override dependencies for testing or plug in fake services so that you can verify UI functionality without hitting databases or whatever. I’m glossing over details, but thinking in terms of breaking dependencies apart will change the way you think about code and, particularly, what abstraction really means.

The final session of the day was by John Lam on IronRuby. I am very excited about the IronRuby project. Ruby as a language intrigues me and being able to use it in the .NET Framework (and thus with projects I’ve already got) is very appealing. Something that was very exciting was getting to see the “world premiere” of IronRuby running on ASP.NET MVC. Note that I didn’t say Rails, but ASP.NET MVC (Rails being the MVC framework on Ruby, while ASP.NET MVC is the… MVC framework on ASP.NET :-)).

All in all, I really enjoyed the conference. Something I didn’t quite expect (having never been to Tech Ed), was that there was very little that I saw that was completely new to me. This is likely a sign that my feed list is far too long, but you can stay relatively current if you will just spend an hour or so a day reading blogs! More and more, I’m beginning to feel that the actual face to face communication is where the real value in conferences comes from. Being able to talk to people who face the same problems you do every day or getting to speak with the people who work on the .NET Framework every day carries a lot more value. Blogs provide plenty of very current and relevant information, but text can communicate only so much. If you’re a developer, there are plenty of other resources outside of expensive conferences like Tech Ed that are available like user groups (hi FSDNUG!) and local conferences (hi DevLink!) that can give you a lot of the value. If you’re not already participating, why not? Get involved²!

¹ Composite Application Guidance for WPF? Composite Application Library (CAL)? Why couldn’t we have stuck with Prism, guys?² I didn’t realize this post would turn into a call to action to get involved, but that’s what stream on consciousness writing does I suppose.

After a short hiatus, I’m back with yet another day review of Tech Ed. Just one more after this!

The first session I attended on Day 3 was with Luke Hoban and Ted Neward and was entitled “the Busy Developer’s Guide to F#.” If you haven’t heard about F#, it is a product of Microsoft Research that “[combines] the efficiency, scripting, strong typing and productivity of ML with the stability, libraries, cross-language working and tools of .NET.” If that didn’t make sense, the gist of it is that F# is a functional language built on top of .NET. Look at the Getting started with F# page for details. The really interesting thing about F# is that the plan is that it will actually graduate from Microsoft Research and become a full blown product from Microsoft. The session itself was great – Luke did the demos while Ted did the talking basically. I’d really like to look into this more. I’ve got the latest version installed, but I haven’t written anything substantial yet.

The next session was with Jeffrey Palermo and was entitled “Architectural Concerns for ORM.” While the session was on ORM, what I really got out of it was effective communication of topics like separation of concerns and true decoupling of architecture. I’ve understood the concepts, but I am very ineffective at communicating those concerns to my coworkers. Jeffrey did an excellent job of communicating this and I appreciated that.

One of the most random things that occurred while at Tech Ed was at lunch on day 3. I sat down for lunch and a few guys sat down at the table. Every one of them had Sun badges on. Yes, Sun Microsystems, the guys who make Java. I was curious, so I asked what was going on. :-) They were there basically to see what Microsoft was up to. Makes sense I guess. I personally hadn’t coded Java since college, but it was still really interesting to talk to them. We all geeked out on Java, dynamic languages (like JRuby and IronRuby), mainframes, and horror stories about hardware (like when the sewage backed up into our computer room).

After lunch, I attended a session from James Newkirk on Unit Testing. If I were to summarize the session in a sentence, I’d call it “Reasons Why I Wrote xUnit.” James’ story is interesting because he is also one of the original authors of nUnit, which was heavily influenced by jUnit. After James left the nUnit, he decided that current thinking on testing frameworks was a little off and he and Brad Wilson created xUnit. The session was very interesting and, as a result, I’m now trying out xUnit on one of my current projects. Easily my favorite thing about xUnit is the change from the [Test] attribute to [Fact] attribute. Unit Testing, or more accurately Test Driven Development, is not really about testing, but creating specifications and design (see Behavior Driven Development which is also an attempt to drive this point home).

After the session, I went up to ask James some questions, but he needed to head down to an “Ask The Experts” session he was giving on TDD. I ended up walking down with him and Peter Provost and talked to them about testing, TDD, design, etc. for a good hour. It was really informative and I got some great advice.

Continuing in my never-ending (at least until day 4) review of Tech Ed, this post will talk about how the second day of the conference went.

At breakfast, I got to sit down at the same table as Sara Ford, a PM at Microsoft on the CodePlex team and a well known for her Visual Studio Tip of the Day series. That experience sort of reinforced the fact that you really do get to interact with the people who are working on the tools that we use every day.

The first session from that day was entitled “Nine Essential Tools for Every Developer.” I left early because I didn’t notice the subtitle that told me the session was actually about Office Power Tools. I don’t currently develop any Office interop applications, primarily because we’re still supporting Office 2000 (if not 97). It wasn’t exactly the most accurate session title.

I attended a session by Drew Robbins on hosting WCF in IIS7. I am seriously excited about IIS7 and it really makes me want to move my development machine from XP to either Vista or Server 2008. It won’t really make a difference because we’re still targeting Server 2003 (and thus IIS6), but it is still awesome. I got a lot more out of this session on IIS7 than I did on WCF hosting. The best part of the session for me was the demo of the IIS7 PowerShell provider.

At lunch, I got to hang out with the TwitterTribe.

I didn’t catch everyone’s name, but the picture above has (from left) Colin Neller (http://twitter.com/cneller), Scott C. Reynolds (http://twitter.com/scottcreynolds), and Alan Stevens (http://twitter.com/alanstevens) (after the guy in the blue shirt). The guy on the right just out of the picture is Dan Hibbets (http://twitter.com/MobilityMatters). Keith Elder (http://twitter.com/keithelder) swung by later as did Cory Smith (http://twitter.com/DualBrain). I apologize to those that I missed (leave a comment and I’ll add you in, too). We had a lot of fun geeking out and thanks to Alan for organizing it. Alan even put together a poster with the “Twitter is having problems” image so we would know where to meet up. :-)

After lunch, I attended a session by Scott Hanselman on Dynamic Data in ASP.NET. Scott is a great presenter, but you already knew that if you’ve watched any of his sessions or screencasts. This session served as a part 1 to a two part session, but I skipped out on part 2, because I had to catch the session on the Managed AddIn Framework.

The session on MAF with Jesse Kaplan was very exciting to me. Some of the readers will know that the primarily application that I work on dynamically hosts other application in it. I deal with things like Assembly Binding, Assembly Loading, versioning, etc. every single day. I am really excited about System.AddIn. Having the ability to load up addins in separate AppDomains to have isolation from your host to your addin is a great feature. Honestly, I know this could be done before, but the real benefit for us is the ability to host our addins (that have a UI) in a separate AppDomain. Through some very nasty hacking, I was able to get WinForms UI to run in a separate AppDomain from the host WinForms UI, but it was not ideal by any means. If you want to do this sort of thing, look at System.AddIn. I’d like to present on MAF at the user groups in the area at some point, so if you’re at all interested in this, let me know and I’ll see about putting some information together.

That pretty much finishes up my second day of Tech Ed. Just two more days of review left!

I’m continuing my review of Tech Ed from yesterday. Yes I still realize that I’m a month behind. :-)

So, after breakfast, I imagine what everyone will be interested in is the keynote by Bill Gates. Here’s the view I had after sitting down:

Woohoo! Below is my great picture of Bill Gates, too. I tweaked the image slightly so that you can spot him.

Anyway, keynote… yeah. Sort of boring. They started off with the Bill Gates Retirement Video. I think there might have been a little bit more content than the first time it was released, but still, nothing new. There was talk about Oslo, but I wasn’t really interested. I don’t really want modeling tools to improve architecture, when the drag/drop designer tools are leading me away from good architecture anyway. If you’re interested in any more regarding the keynote, check out Herding Code’s overview of the keynote announcements.

The first real session I attended was by Grigori Melnik and he covered Enterprise Library 4. Honestly, my feeling regarding EntLib is way too much XML configuration. I’m also not a fan of the config editor for the configuration. I’d really rather configure it in code or using some DSL support or something. I’m interested in Unity (the one release from Microsoft that got to keep its cool name!) somewhat, though. Unity is Microsoft’s offering in the IoC/DI space. It has gotten some flak, but it really isn’t all that bad from what little I’ve used it. I do like that it is very lightweight and the fluent interface it provides for component registration is pretty good. The session itself was mainly demos, though, so not much content.

I walked into a session by Sara Ford on CodePlex, but I didn’t stay too long because it seemed to be a walkthrough on how to use the CodePlex site itself.

Another session I attended that day was by Jimmy Schementi entitled “Dynamic Languages and the Web.” You can probably guess that this one was primarily on IronRuby. As you might guess, a lot of the talk revolved around how dynamic languages will work with Silverlight. Jimmy pointed out the Silverlight Dynamic Languages SDK which provides tooling for running dynamic languages under Silverlight, including IronRuby, IronPython, and other DLR based languages. It was pretty cool seeing a Rails app running on IronRuby. Jimmy also showed us an IronRuby version of Try Ruby, which runs in the browser with Silverlight instead of having to ship the Ruby commands back to the server to be executed. (note – if you haven’t tried out Ruby, go use the Try Ruby site. It is an excellent introduction into an awesome language)

I spent the rest of that day in Hands on Labs (see my Virtual Labs post to get an idea of the what the HOLs were like) and talking to the Microsoft guys. I spent time talking to a couple of developers on the .NET Framework team (whose names I unfortunately missed) and asked them a little bit about the MAF (Managed AddIn Framework). Their advice on that was to check with Jesse Kaplan (does Jesse have a blog I can link to?) so I did exactly that later in the week. I also spent time talking to them about versioning headaches and how we attempt to deal with breaking changes. It was interesting.

Afterwards, they told me that the MSDN documentation guys were looking for feedback, so I swung by there. I didn’t get much information from them, but I tried to give them a lot of personal feedback on my feelings towards MSDN documentation. I currently still use Google to get to most of the MSDN help. I told them I used the local MSDN help up until Visual Studio 2005, at which point the help application because too slow to use. They seemed very welcome to hear feedback and I really think they’re trying to improve.

All in all, it was a pretty good first day. That night was the vendor party where you basically sold yourself and your contact information for t-shirts and other swag. :-)

I’m guessing it has been so long since Tech Ed that no one will be interested in hearing how it went, but you know – I’m going to post about it anyway.

I’m planning on doing a blog post per each day of Tech Ed so that I can (hopefully) give each session its due. The first day was the preconference session. The session I attended was entitled “Building Great Web Applications with Silverlight” with Jeff Prosise. The session covered both versions 1 and 2 (only beta 1 though). It was unfortunate that beta 2 wasn’t announced until later that week, so Jeff just got to hint at differences that would be coming out with the next release… which came out a week later. The hints were actually sort of funny, because Jeff was officially under NDA, so he would say things like, “this might change soon… hint, hint.”

The first half of the session was almost entirely getting most people up-to-date with WPF, so it turned into a review session for me. The bulk of what was new for me was better coverage of the network and I/O stack that Silverlight provides, which filled the rest of the session. Silverlight 2 brings a portion of the CLR to the browser (called the CoreCLR) so you have access to WCF and System.Net functionality as well as file I/O access via isolated storage. Threading is also provided so that’s nice. Something interesting to note is that Silverlight won’t provide any synchronous versions of methods that also have asynchronous methods. For example, the System.Net.HttpWebRequest will only provide the BeginGet* methods, not the synchronous Get* methods. The reason for this is because they’re trying to trim everything out that isn’t needed to cut the size of the CoreCLR down. Makes sense to me.

Well, that’s about it for the preconference. Like I said, more of a review than a lot of new information. I did get to have lunch that day with Colin Neller and Robertjan Tuit. Rob was telling us about the hair styling convention that was going on at the same time as Tech Ed. What a combination of conferences – geeks and hair stylists.

That night I attended Party With Palermo. While there, Jay Smith and I talked about a potential ALT.NET Open Spaces event that Raymond Lewallen is planning. I’m not so sure it will be happening in mid-July seeing as it is already July, but who knows? If it does, I’m in! I also got to see Scott Hanselman from across the room. I was telling Colin that I wanted to go up and say hi, but I didn’t really know how to approach Scott without, as Colin put it, “feeling like a groupie.” I mean, seriously, “hey Scott, I read your blog and listen to Hanselminutes and watch your videos and… man, you are awesome!” Missed opportunity I guess.

That does remind me of a funny occurrence that happened that night that I heard about secondhand. The three other guys I went to Tech Ed with were all sitting around at the party and Scott came over to sit by them. As you might imagine, everyone had name tags on. One of the guys sees “Hanselman” on Scott’s name tag and asks Scott if he is any relation to Scott Hanselman. “Uhh, yeah, I’m Scott.” “The Scott Hanselman?!?” Sure am glad I didn’t look like a groupie. At least I recognized him. :-) I told this unnamed individual that he later should have asked Scott to sign one of his books as “the Scott Hanselman.” Yet another missed opportunity! :-)

I’ll see about getting my overview of the rest of Tech Ed up later.

I've been meaning to get a local version of my blog running so that I could test changes and tweaks to my theme and I finally found some time yesterday to do that. Can you tell the difference? Basically, I added the social networking links on the right as well as the Tech Ed 2008 badge.

This will be my first time to go to Tech Ed, so I'm excited. I've only been to one other conference and that was devLink last year (which was awesome - I still need to register for this year!). There will be 3 other guys from my company going and I know that Randy Walker and I think Jay Smith will be as well. Anyone else out there going? Let me know in the comments! Also, anyone planning to attend Party with Palermo? I haven't registered yet, but I'm thinking about it.

Speaking of conferences, the Northwest Arkansas area is planning a technology summit. I've missed out on the discussions about it so far but I'm hoping to make the next meeting to talk about it. We'll make sure information gets out regarding the specifics so that everyone can participate.

If you live anywhere around Memphis, be sure to be there on November 10. That is when the Memphis Day of .NET is scheduled. It was just announced today that Charles Petzold will be delivering the keynote as well! Charles has already posted about it on his blog. I'm incredibly jealous of all of you who are planning on being there - I had been planning to go but then when I found out when it was scheduled, I realized I had conflicts and wouldn't be able to make it. Of the other speakers scheduled, I got the chance to meet both Keith Elder and Jeff Blankenburg at DevLink and I know their presentations will be great. I know that Colin and others have put a lot of hard work into making the Day of .NET great, so if you get the chance, go out there and show them your support!

My wife and I got back from Nashville last night and we had a great time. While she went around shopping at garage sales and hanging out with family, I got to spend some time with some great developers at devLink. The conference was incredible. I'm still amazed that they were able to do so much with only $50, but no complaints here :-)

Here are a few of the high points from the conference:

Keith Elder had a great presentation on the Enterprise Library. It was especially good to hear from someone who is using EntLib successfully from a WinForms perspective. I also got to talk to him a little after his presentation on some of their techniques for storing configuration across smart client applications.

Josh Holmes is a great speaker. I'm not at all surprised that he is one of the hosts for the new Code To Live! show. He is clearly passionate about the coding craft. He shared some great information about the DLR with us.

I got to hear Dave Laribee talk about Domain Driven Design, which was great. I also spoke with him about ALT.NET and Microsoft's upcoming MVC framework for ASP.NET. He told me that there are already plans for the next ALT.NET conference which is great news.

Ron Jacobs had the closing keynote on Saturday evening that covered Test Driven Development and the Model View Presenter architecture. It was a great presentation and it was encouraging to have Microsoft's presence there encouraging and pushing TDD.

One of the best things about the conference was how approachable everyone was. I got to meet a lot of great people and I even got the change to give Colin grief about winning the blogging contest (not that you can give someone much grief about winning an Xbox 360). My only complaint was that I wasn't able to attend some of the other presentations where there were schedule conflicts.

All in all, the conference was great. The staff and the presenters all did a great job.

I'm getting ready to start the drive to Nashville tonight for DevLink 2007. It will be my first real conference to attend and I'm really excited about it. It will also be fun to get to hang out in Nashville. If you'll be at the conference, look me up!

I know a few of you who are planning on going so you have no excuses to not say hi when you're there! :-)

Reading posts like this one from Jeremy Miller really make me wish I could make it to the ALT.NET conference in Austin. There are almost too many good points in his post for me to comment on, but I'll go ahead and try.

I completely and wholeheartedly agree with his comments on the general lack of knowledge that developers have regarding real OOP and software design concepts. Many of the developers I work with are terrified of the upcoming releases of the .NET framework. The thing is, they're just new releases in tools and libraries. Sure, they provide value - I don't know how many times I realize that some UI I'm trying to work with in WinForms would be ridiculously easy to build in WPF. And WCF does a great job at abstracting the goo that connects all of my objects. However, if I don't have a good background in solid OOP design and separation of concerns, WCF won't help me at all anyway. These new tools aren't going to do anything to make me a better developer. I'll still be able to write awful code.

I commend these guys for trying to get to the heart of the issues in the .NET community and I hope that the solution isn't to just move to Ruby and Ruby on Rails. My opinion is that we have to fix the problems in our community - if we just migrate to another community, the problems and lack of knowledge will eventually follow us. I can still write bad code in Ruby, too.

Being one of the guys who won't be able to make it, I have a few requests. I would really like to see the content from the conference posted online or made accessible to those of us who won't be able to make it, particularly considering the fact that the conference sold out. Microsoft did a good job in posting content from both MiX and TechEd this year and I think that would be a welcome addition from this conference as well.

Keep pushing this knowledge out - I'm optimistic that things will improve.

Well, I got back from the .NET Roadshow last night. It went really well, too. The conference lasted two days with three tracks.

The first day was all WCF with Juval Löwy. Juval is a great speaker and really knows his stuff. I mean, seriously, the guy is a genius. There is a reason that Scott Hanselman put him on his list of "Smart People and their pages for Utils they Wrote" (a subitem of his Ultimate Tools). He really pointed out how WCF will change the way we write code. Your implementation of a service might look like a class, smell like a class, quack like a class and walk like a class... but it isn't a class anymore. It is a service. What does this really mean? Well, it means this thing that looks like a class now inherently supports transactions, threading, queuing, throttling, security, and more. Now, I'm going to insert my little bit of reality here - this service functionality isn't all magic. You have to configure your service and you have to host it. You don't just say myVar = new myService() or something like that. But there is still a ridiculous amount of power that WCF gives you out of the box. I like it.

The second day, we got to choose between a security-focused track by Michèle Leroux Bustamante and a Workflow/WPF track by Brian Noyes. I chose Brian's track simply because I know we'll be using WPF soon and because I have zero background in Workflow. Workflow really is pretty cool, though it is a little hard to explain. The benefits, as far as I'm concerned, come in visualizing business processes so that you can verify functionality with your users via a flow chart instead of trying to explain through code. The more activities that you create, the closer that your workflow can get to true business/domain terms. Also, I didn't realize it until Brian mentioned it, but Workflow supports persistence, so you could conceivably have a 6 month long workflow that persists between machine reboots and all of your logic still flows without any problems. Very cool.

I had the most background in WPF ahead of time, so I didn't really learn anything new. Having purchased Adam Nathan's book on WPF as well as having watched a multitude of dnrTV episodes on WPF, I had a pretty good background on what WPF is capable of. Needless to say, WPF is awesome. I still couldn't use Expression Blend to safe my life, but the entire platform is sweet. I think my favorite example of what you can do with WPF is the example from Adam's book on customizing the ToolTip so that it looks like the tooltips from Office 2007. It doesn't sound like something to get all that excited about, but the ease with which it is done really shows just how powerful the WPF composition engine is.

All in all, I really enjoyed the Roadshow. If you've already got some background in .NET 3.0 or are using it, I don't know if you would gain much; however, if you're like me and haven't had a chance to really dig in, you can really learn a lot and see some of the capabilities that .NET 3.0 will give you.

I'm off to .NET Roadshow 2007 in Dallas! The speakers are Juval Löwy, Michèle Leroux Bustamante, and Brian Noyes. My hope is we'll be doing some pretty heavy .NET 3.0 development at work soon (primarily WPF and WCF I would guess), so watch for some .NET 3.0 related content. I'll post when I get back about how it was and, if I get a chance, I'll try to post some updates from the conference as well.

I'm pretty excited this year, because I'll be going to my first developer conference. devLink 2007 will be held in Nashville, TN on October 12 and 13. You can't beat the return that you'll get from this conference because, for the low, low price of $50, you'll get to hear from such speakers at Brad Abrams, Scott Bellware, Jean-Paul S. Boodhoo, and Rockford Lhotka just to name a few. All this for $50!!!

Even if you can't get your employer to pay for this conference (I don't know if mine is or not yet), it would still be worth it to check this out. Besides, you can go see the Parthenon while in Nashville. Having seen the original, I'd say Nashville's copy is pretty cool, too.

Evan Hoff posted about the conference and his post already has 13 kicks on DotNetKicks, so excitement about the conference is building. Sign up now!

Leave a comment or email me if you're planning on going. It'd be great to meet some of the other developers out there.