Jafar has always been a big fan of Rx (including his days at Microsoft), ever since he first learned about it by watching a C9 video with Erik Meijer and Brian Beckman geeking out on the math and theory behind Rx. Netflix is literally powered by Rx.  Jafar really gets Rx. If you're struggling to wrap your head around it, even at the conceptual level, this conversation should make things crystal clear. Go Rx!

Of course, anytime you talk about Rx and Erik Meijer is roaming around the halls nearby, chances are pretty good that he'll drop into the conversation - literally. Does it happen this time? Will the great Erik Meijer appear? You'll need to watch this interview to find out...

Tune in. Enjoy!

In addition to the usual support for .NET and JS we're very pleased to announce the release of the C++ Rx library! Now, C/C++ developers get to experience the power of LINQ + Rx!! Rock and roll.

Congratulations to the Rx team!!!

I caught up with Bart at his whiteboard (of course) to discuss the significance of this release as well address some of the great additions to Rx as outlined below (many of the topics below have been discussed in depth in other Rx interviews with Bart.) We also talk about the new experimental build shipping model. Much of the time is spent talking about the portable libraries architecture for Rx for Windows 8, .NET 4.5, WP7/7.5 and beyond. Bart has been very, very busy and as usual his engineering is golden.

Tune in! It's always a pleasure to geek out with Bart. So much to learn. Congratulations to the Rx team!!!

The highlights of Rx 2.0 include:

• Support for building Windows Store apps for Windows 8. This includes primitives to synchronize with the Windows XAML CoreDispatcher and interop with WinRT events and IAsync* objects.
• Support for Portable Class Library projects, allowing code reuse across ".NET Framework 4.5" and ".NET Framework 4.5 for Windows Store apps" projects. We're planning on adding Windows Phone 8 support to this going forward.
• Integration with the new C# 5.0 and VB 11 "async" and "await" features. In Rx v2.0, you can await an observable sequence, allowing one to apply the power of Rx to the new asynchronous programming model.
• Enormous performance improvements, with a 4x speedup of the query pipeline, vastly reduced object allocation rates, massively increased throughput of schedulers, and much more.
• An improved error handling strategy, enabling higher resiliency and proper resource cleanup for queries in the face of user errors at various levels.
• Thorough revisit of the way we deal with time, to improve efficiency and predictability. This includes better support for periodic timers, improvements to absolute time scheduling, etc.
• Various new and improved query operators.

Most of the time is spent at the whiteboard - very comfortable and natural place for Bart!  

Note: there is a lot of time in this interview, both in terms of interview length and the notion of time itself. Use at your own risk and watch out for unexpected wormholes.

More on Rx 2.0 RC:

This new release of Rx includes a number of improvements to the way we deal with time. As you likely know, dealing with time is a complex undertaking in general, especially when computers are involved. Rx has a lot of temporal query operators to perform event processing, and therefore it needs to be able to schedule work to happen at particular times. As a result, notions of time exist in virtually any layer of the system: from the schedulers at the bottom (in System.Reactive.Core) to the query operators at the top (in System.Reactive.Linq). [Bart De Smet]

• Download page:  http://go.microsoft.com/fwlink/?LinkID=255295
• Bart's epic blog post:  http://blogs.msdn.com/b/rxteam/archive/2012/06/17/reactive-extensions-v2-0-release-candidate-available-now.aspx

Highlights of this release:

Support for .NET 4.5 Beta.

Support for .NET for Metro style applications and Windows 8 Consumer Preview.

Rx Portable Library Beta.

Await support on IObservable<T>.

Async variants of various operators.

Scheduling using async methods.

Generalized time-based operators.

Improved performance.

You can read much more about this release in Bart's (lengthy) blog post, including download links and installation instructions.

Today marks the end of a drought and the beginning of more regular appearances by the dynamic duo. The band is back together!

Introducing a new Channel 9 series - Beckman Meijer Overdrive.

One of the truly great things about Brian Beckman and Erik Meijer is their natural ability to explain complex subject matter in ways normal people can readily understand, all while engaging and entertaining us. In this new series, Brian and Erik will get together each month to make music in the form of conversational (and improvisational, of course) jazz. Tune in and learn something new from two programming legends and true iconoclasts. It's guaranteed to put your mind into overdrive.

Here, Brian and Erik recap LINQ and dig into the notion that LINQ is composability. What does that mean, exactly? Where does Rx fit into this? What about the cloud? What's so special about LINQ? As you'd expect, other topics emerge naturally from this conversation as Brian and Erik make their case for a LINQ-ruled world.

We're excited and honored to have Brian and Erik back on C9—and excited, too, that this will be a recurring treat. Thank you, Brian and Erik!

Tune in. Enjoy. Learn.

Here, Bart J.F. De Smet - the lead developer of Rx - and Matthew sit down for a C9 conversation about RxJS (no demos or code-on-screen - this is purely a conversation). Who knows where it will go (will we only talk about RxJS?) and who'll make a cameo appearance at the very beginning Tune in.

Enjoy!

Follow Matthew: @mattpodwysocki

It's been WAY too long since we've had Brian Beckman sharing knowledge, insights and perspectives on Channel 9. This changes now!

Needless to say, I was incredibly happy to spend an hour with Brian learning all about what he's up to these days. Not surprisingly, he's writing code and employing Rx and monads to solve very interesting problems. In this conversation (a code lesson, algorithm survey, a splash of random topical diversion), Brian explains and demonstrates his latest endeavor: implementing the Viterbi algorithm in C#. What's the Viterbi algorithm, Brian? What are hidden Markov models? What are you using this stuff for? Where does Rx fit into this? What's going on? By the way, it's awesome to learn that a Niner has been sharing C# monadic implementations with Brian (state monad, maybe monad).

Of course, no conversation with Brian - a physicist by training and a software architect at Microsoft - is complete without talking about some current physics problem: Finding the elusive Higgs Boson is all the rage these days, so we talk about what it means.

Brian also shares insights on Haskell, functional and hybrid programming languages (C# is imperative, but it provides functional capabilities like LINQ, for example, upon which Rx is built (Rx is LINQ-to-Streams or observable sequences of events, really)...). We also finally discuss his previous work at MS that we never got a chance to talk to him about while he was doing it. Before joining the Bing Mobile team, Brian was working on a project to create a new functional programming language. What was it?

Thank you, Brian!

Happy holidays from Channel 9 wherever you are and whatever, if anything, you're celebrating!


Notes and More:

The code Brian demos (download it, unzip it, launch VS, open the solution, then watch this video and play along): https://github.com/rebcabin/DotNetExtensionsImproved

From Wikipedia - information on Markov and Viterbi:

A hidden Markov model (HMM) is a statistical Markov model in which the system being modeled is assumed to be a Markov process with unobserved (hidden) states

The Viterbi algorithm is a dynamic programming algorithm for finding the most likely sequence of hidden states – called the Viterbi path – that results in a sequence of observed events, especially in the context of Markov information sources, and more generally, hidden Markov models.

Thanks again for creating and continuing to evolve LINQPad, Joe!!

Joe's YOW! speaker page

The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff - Mary Catherine (MC), Lisa, Aino, Melissa, and others - for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great developers down under. That's for sure. The speakers are exceptional—Dave and team set a high bar!

Rx v1.11011.11 (Experimental) features include:

Improved Exception Management

Prefer Async Policy

Interoperability with Task<T>

FromEventPattern Support for WinRT Events Various Changes to System.Reactive The New

System.Reactive.WindowsRuntime Assembly

This release of Rx includes support for WinRT interop and to build Metro style applications leveraging Rx for event processing

IAsyncInfo Conversions

Release Notes

Download

I recently visited the great Bart De Smet to learn more about Ix. As usual, Bart clearly explains what Ix is and why they've built this library, what it's for, and when to go interactive. This is a deep conversational piece with plenty of whiteboarding during which we also talk about the current status of IQbservable. Tune in. Learn.

Download the Challenge

Download the Challenge

Today, we're very pleased to announce that Rx is now officially official with the final V1 release! 

Rx V1 will ship as a stable release with professionally-written technical documentation, developer samples and...ready? Product support!!

Since Rx is written and maintained by Erik Meijer's team you can imagine that there will continue to be innovation and experimentation at a quick pace. The Rx cutting edge will manifest itself as experimental releases. The real-world-developer-tested innovations in the experimental releases will most likely find their way into subsequent stable releases, which are the bits you'll want to build your event stream processing empire on top of.

The experimental releases will allow you to see and touch where the technology is heading, as well as help the team go in the right direction, as you have already done. Without developers using Rx in the real world and providing feedback to the Rx team, it is unlikely that Rx would be in the shape that it is today. Thank you!!

Here, I catch up with Rx developers  Wes Dyer and Bart De Smet to get more information (and to see if I can get Wes and Bart writing on the whiteboard at the same time). Tune in,

Congratulations to the Rx team!!

=======================================================================================

Download Rx V1:                         

http://www.microsoft.com/download/en/details.aspx?id=26649 (or using NuGet)

Rx Documentation: 
            
http://go.microsoft.com/fwlink/?LinkId=221892 (conceptual)
http://go.microsoft.com/fwlink/?LinkId=221873 (reference)

Rx Workshop:

http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Introduction
http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Event-Processing
http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Observables-versus-Events
http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Unified-Programming-Model
http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Writing-Queries
http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Schedulers

Rx Forum: http://social.msdn.microsoft.com/Forums/en-US/rx/threads

Welcome to the Rx Workshop! Rx developers (they design and implement Rx) Wes Dyer and Bart De Smet will guide you through a series of sessions that will get you up to speed with Rx fundamentals rather quickly. Tune in!

See the rest of the Rx Workshop tutorials.

2 -> http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Observables-versus-Events
3 -> http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Event-Processing
4 -> http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Unified-Programming-Model
5- > http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Writing-Queries
6 -> http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-Schedulers

Download the Challenge

Download the Challenge

Download the Challenge

Download the Challenge

Download the Challenge

Bart de Smet was in Dublin to talk about the Rx Framework in an event organised by Microsoft and Dublin Alt.Net. In this video Bart shares some of thinking behind the Rx and how it can be leveraged to solve common obstacles that we have all run into when doing asynchronous programming. The presentation walks us through how observables are based on the inverse of the existing IEnumerable interface. From this starting point Bart goes through some practical examples of using the various operators to keep your program's UI responsive while handling streams of data.

At Dublin Alt.Net we organize monthly meetings where we discuss issues that interest us in a loose, informal discussion-style environment. All software developers of every stripe are hereby extended an invitation to participate in the discussion or just come and see what all this Alt.Net stuff is about.

Long live "Volta" Rx!!

C

"Hey Bart, what is MinLINQ, exactly?"

"MinLINQ is an implementation of the LINQ to Objects Standard Query Operators using a function-oriented layered approach. Based on three essential operators called Ana, Bind and Cata, others are implemented. While the current implementation focuses on IEnumerable<T> exclusively, the same layering can be used to a dual IObservable<T> implementation."

Sit back, relax and jump into the layered functional rabbit hole where we meet some interesting characters named Ana, Bind and Cata. It's all about the essence, Alice.

Happy New Year!

• Support for the new C# await keyword (Observable.GetAwaiter)
• ToTask and ToTaskLast operators
• IAsyncEnumerable interface and all standard query operators for this interface.

Here, Rx developers Jeffrey Van Gogh and Wes Dyer dig into what these new additions mean and how they work.

Get Rx here. Learn the basics (Rx for beginners) here. Provide feedback to Jeffrey and Wes here.

Enjoy. Learn. Code.

PS: Check out Bart de Smet's introductory presentation on Rx from a recent DevCamp.