Matthew Podwysocki's Blog

Lately in my series on the Reactive Extensions, you’ll have noticed I focused quite a bit on the IObservable<T> and IObserver interfaces as well as the extensions methods that are included.  There is one thing, however, that might have been missed with the release of the Reactive Extensions is the inclusion of System.Interactive.dll.  The idea behind this is to include many of the extension methods that are available to IObservable<T> and port them to work on the IEnumerable<T> interface.

In the previous post of the Introduction to the Reactive Framework series, we covered how to create new IObservable<T> instances, either from scratch or from existing sequences.  What this allowed us to do was turn an operation which was previously interactive, such as iterating over a collection, to a reactive, where I could have multiple listeners reacting to the same collection concurrently.  This has nice implications for allowing us to scale our application in interesting ways.  This time, let’s take another angle on making asynchronous programming easier.

As you may have noticed, I’ve been blogging a bit about the Reactive Framework, now the Reactive Extensions for .NET (Rx) and how it will change the way we approach asynchronous and event-based programming.  Just as LINQ to Objects changed the way we deal with collections, The Reactive Extensions will change the way we deal with asynchronous and event-based programming.  Fast forward to today, Rx has been released on Microsoft DevLabs for not only .NET 4 Beta 2, but also .NET 3.5 SP1 and Silverlight 3 as well. 

In the previous post in this series, we covered how to turn .NET events into first class values through IObservable instances.  By doing so, we were able to do much more interesting things than just subscribe and unsubscribe, instead we were able to create a mouse drag event with little effort through composition.  In this post, let’s look at going from push to pull by turning collections into IObservable<T> instances.

In my previous post in the Introduction to the Reactive Framework series, I discussed the duality between the IEnumerable/IEnumerator and IObservable/IObserver and how that enables us to generalize the ideas from LINQ to Objects to LINQ to Observables/Events.  After the last post, I was asked how we go from events to Observables, so let’s tackle that in this post.

As a group, we’ve been focusing a lot on technology on such things as JavaScript, MongoDB and so on.  This month, I’d like to take a step back as a group and instead focus on some soft skills.  When I started this group back in 2007, I had the idea that this group would help others not only become better technologists in a wide array of technologies, but also better teachers as well.  On November 24th, we have Jeff Casimir to help us understand how to become a better teacher with his presentation “Stop Talking, Start Teaching: 5 Rules for Successful Presentations and Demos”.  Listed below are the details:

In my previous post, I talked a little bit about the parts of the Reactive Framework that are coming to the .NET 4 BCL as well as their implementation in F# as part of F# First Class Events.  This time, let’s come back to the Reactive Framework itself from which the IObservable<T> and IObserver<T> originated.  As you may remember, you can play with the bits of the Reactive Framework from the Silverlight 3 Toolkit. 

Lately, I’ve been covering a lot of F# First Class Events as well as the Reactive Framework which has been leading up to a head as it were.  It has been announced through Channel 9 that .NET 4 will include the two major interfaces from the Reactive Framework, the IObservable<T> and IObserver<T>.  Today, as Don Syme announces with the release of the F# October 2009 CTP and F# for Visual Studio 2010 Beta 2, those two interfaces, the IObservable<T> and IObserver<T> have been integrated into F# First Class Events.