Well, I was toying around with the idea for about a month or so, and finally I got around to actually record & editing that.

Highlights:

• Vastly improved sound quality. I think you'll enjoy it.
• Vastly extended in time & scope. For some reason, this screencast is longer than many full length movies. We also write our own bus implementation from scratch, and discuss the implementation details there.
• This is more of a low level discussion, not a high level architectural discussion about why you want a bus (well, I do talk about it a bit, but mostly we implement the bus).
• The first 45 minutes are dedicated to moving from an old style RPC to an async batching bus approach, that still uses the request / reply. The rest is dedicated to building the one way, message passing, queue based, service bus.
• There are some interesting challenges there, and I hope you'll make sense of my grunts as I write the code.
• The last hour or so of the screen cast it live coding, and you get to see how I revert some design decisions as they turn out to be problematic.

The technical details:

• Total length: An hour and forth minutes(!)
• Size: 160 MB
• Code starts on 04:31

Go to download page

Just finished recording Hibernating Rhino #8, somehow, it is 1 hour and 40 minutes long.

Then again, we get to implement a full service bus and some variations.

I got quite a few requests for more information on this, beyond the short documentation in this post. This is not something that I was very happy with because I feel that Rhino Igloo represents a compromise that I am not very happy with. Consider this the product of a developer longing for MonoRail while having to deal with WebForms world.

I am not making excuses for this project, it is meant to serve a very specific goal, and it has done that very successfully.It is also extremely opinionated and may not fit what you want to do.

• Length: 57 minutes
• Download size: 79 MB
• Code starts at: 11:14

You can download the screen cast here. There is a secret message there, let us see if you can spot it.

Update: looks like the file I uploaded is corrupted, I'll upload a new one soon, in the meantime, I removed it from the download page.

Update 2: Uploaded a good version, it is available now.

This is a screen cast that was spawned as a result of the discussion in the ALT.Net about the ideal IDE. Glenn Block mentioned that something that would be cool is:

Ability to instantly search for a specific artifact (kind of like Google / windows live search). As I type it in, I see the filtered results.

I like challenges, and I happened to know some components that can make this very easy, so I set out to build the foundations of a code search engine that can match the above requirements. Now, refining it to the point where it is usable should take about a day or two, I think, but all the basics are there.

• Length: 28:07:00
• Download size: 40Mb
• Code starts at: 1 minute mark

This is basically glue code, so be aware of it. It meant to show you how, not to actually show production level code to handle all the required scenarios.

You can download the screen cast here. As usual, the sound quality is probably suspect, and I recorded it at 2AM, so I am not sounding my best there.

After reading about Erlang, I got very excited about doing hot code swapping, and always on applications. I decided that this is something that would be cool to do on the CLR. So I did, it was very easy.

The screen cast is a short one, less than 25 minutes, but it covers all the concepts, and we have dynamically updated code in the end. :-)

As usual, the sound quality is suspicious, and I am probably speaking to fast.

• Total length: 00:24:12
• Download Size: 34.2 Mb
• Code starts at 2:05

Memorable code:

I think it is telling that I am using the Command pattern to print hello world.

You can get the code here

Okay, here is the first episode in my OR/M challenge series. It mostly deals with the MonoRail skeleton project and with setting up the domain model in a TDD fashion. I am not sure how interesting it is, because about 60% of it is building the Active Record entities, and explaining how it works, but it lays a foundation that I will use for the next few episodes.

Lots of Um..., I am afraid, but at least I am speaking in a normal speed :-)

• Total length: 55:44 Minutes
• Download size: 77Mb
• Code starts from ~4 minutes into the episode.
• Getting the Latest code - will be updated for new episodes
• Getting the Code from the episode

The download page is here: http://ayende.com/hibernating-rhinos.aspx

I have some ideas about where to take the next episode, but this is something that is mostly dependant on your feedback :-)

Well, I have finished the first episode of the OR/M Challenge, and it is now in the process of being uploaded to the server. I am going to sleep, based on some good advice that I received, so I will do the actual publishing in the morning.

What is really interesting is the numbers you can see here: http://ayende.com/hibernating-rhinos.aspx

Nearly ten thousands downloads for each of the previous episodes? Wow!

Okay, here it is. This is a little diferent style than the one I have made before. This isn't scripted at all. This is literally a recording of me trying to solve the Event Broker issue. As I have mentioned, I have spiked the issued previously, but not in any serious manner.

As a result, you can see me stumbling over issues in the implementation, and it is much less professional sounding. It turns out to be less than one hour recorded (+ 5 minutes spent checking the Rhino Mocks source code "off stage"), and I think that I have a good solution for the Event Broker issue.

I am afraid that at times I have been reduce to unintelligable muttering at time, but I hope that it is still valuable.

Stuff that is covered in the screen cast:

• Event Broker
• Declerative Event Wiring
• Registering to events from classes we don't own
• Avoiding memory leaks

The code starts at 2:30 minutes, and it is pretty much just code (and my mumbling) from then on.

As usual, the code is supplied, and the download page is here.

I have just finished putting together the second episode of Hibernating Rhinos. This one tooks several days and a lot of effort to produce. The download page is here, where you can also download the first episode, talking about Rhino Mocks.

The screencast is basically taking implementing similar functionality in both Web Forms and MonoRail, while I talk about the differences between the two approaches. I spent quite a bit of time explaining most of what I do when I am writing MonoRail code, so I hope it would be clear. This episode is not meant to be an introduction to MonoRail, it is merely a show & tell episode.

I am also afraid that I fell into the common trap of Web Froms vs. MonoRail comparision, and I focused quite a bit of my time on the UI layer, instead of focusing more on the controllers side of things, which is more important.

• The overall length: 1:14:32
• Download size: 60Mb
• The big sigh at the beginning? That was the fourth time that I recorded this episode!
• I am showing code from 09:25 onward.
• Fun part that you shouldn’t miss:
  
  It should fails... It doesn't fails... It should fails... It doesn't fails...

• From 05:10 to 08:00  - Web Froms Rant (come to think about it, there are a lot of those J )

Am I talking too fast? Am I making any sense?

Errata: in talking about the view engines, there is a section that might looks like I am taking credit for building Boo, just to clarify, I am an avid user of Boo, but I can't claim any credit for it. What I meant was that I built Brail, which uses Boo.

I just can't believe the numbers: