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.

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

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

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.

"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!

Bart De Smet is one of the highly talented software engineers on Erik Meijer's team and the chief architect of the LINQ to Anything dream. You should watch his excellent PDC10 session on this topic.As you learned on Channel 9 Live's PDC10 conversation with Wolfram Schulte and Erik Meijer, Z3 is a theorem prover (the fastest in the world, in fact). Z3 is one of several advanced software engineering technologies coming out of MSR's RiSE team.

A while ago, Bart implemented a LINQ to Z3 library and I've wanted to dig into this with him for some time. Recently, I got the chance to do just that and it makes for an excellent episode of Going Deep.

Bart writes in his initial post on the LINQ to Z3 project:

With LINQ to Z3 my goal is to abstract away from the low-level Z3 APIs and provide nice syntax with rich static typing support on top of it. The basic idea is the following:

• Define the “shape” of a theorem, e.g. what symbolic names (and their types) to use;
• Express constraints over those symbolic names using LINQ syntax (more specifically the where keyword);
• Ask the resulting object for a solution, resulting in an instance of the “shape” type specified at the start.

An example of LINQ to Z3:

var theorem = from t in ctx.NewTheorem<Symbols<int, int, int, int, int>>()
              where t.X1 - t.X2 >= 1
              where t.X1 - t.X2 <= 3
              where t.X1 == (2 * t.X3) + t.X5
              where t.X3 == t.X5
              where t.X2 == 6 * t.X4
              select t;
var solution = theorem.Solve();
Console.WriteLine("X1 = {0}, X2 = {1}, X3 = {2}, X4 = {3}, X5 = {4}", solution.X1, solution.X2, solution.X3, solution.X4, solution.X5);

How does LINQ to Z3 work, exactly? Why did Bart do this? What is Z3 useful for? How does it work? Here, we get answers to all of these questions with lots of meaty whiteboarding and demo at the end of the conversation. As usual, there is a lot of information presented here and in a way that is readily understandable by non-experts - this is one of Bart's excellent traits: clearly explaining complex subjects so you don't have to be as smart as Bart to fully understand. I left Bart's office with better understanding of LINQ, Z3 and LINQ to Z3 (also Solver Foundation and Bart's definition of monad....). Thank you, Bart!

By the way, this is espisode 201 of Going Deep. Bart and LINQ were the focus for the 100th episode. It's nice to have this 100 episode cycle (LINQ to Anything is LINQ to Everything in this revolution). Thanks to all who have made this series truly interesting! Here's to 200 more.

Tune in.

Learn. Enjoy. Code.

Aufzeichnung vom DEVcamp 2010 in Wien, am 12. Oktober 2010

Organisiert von den Partnern TechTalk, Cubido und CSS.
Microsoft Österreich unterstützte das Event als Hauptsponsor und hat auch selbst einige Sessions abgehalten.

At Microsofts Professional Developers Conference (PDC) a few years back, we introduced the LINQ project to solve the impedance mismatch between various data models by means of integrated query syntax in mainstream programming languages. Today, we’re seeing a rich ecosystem around LINQ providers that allow developers to reach out to many more data sources. However, there’s a lot of opportunity left to democratize even more data models. Based on the theory of monads, we’ll explore the incredibly powerful nature of query comprehensions to build reactive queries.
 
Asynchronous, event-driven "reactive" programming is way too hard in today's world of development tools and frameworks. The huge amount of manual and error-prone plumbing leads to incomprehensible and hard to maintain code. As we reach out to services in the cloud, the desire for asynchronous computation is ever increasing, requiring a fresh look on the problems imposed by reactive programming. Centered around the concept of observable data sources, Rx provides a framework that takes care of the hard parts of reactive programming. Instead of focusing on the hard parts, you now can start dreaming about the endless possibilities of composing queries over asynchronous data sources, piggybacking on convenient LINQ syntax.

In this session, we'll cover the design philosophy of Rx, rooted on the deep duality between the interactive IEnumerable interface and the new reactive IObservable interface in .NET 4.

From this core understanding, we'll start looking at various combinators and operators defined over observable collections, as provided by Rx, driving concepts home by a bunch of samples. Finally, if time permits, we'll look at the Reactive Extensions for JavaScript which allows us to take the concepts we already know from Rx and apply them to JavaScript and have deep integration with libraries such as jQuery.  Democratizing asynchronous programming starts today. Don't miss out on it!

Whiteboarding:

• Expression trees recap (lambdas convertible to either anonymous methods or expression trees)
• How LINQ to Objects versus LINQ to SQL works, introducing IQueryable<T>
• Look at the Queryable extension methods and how they stitch expression trees together
• Differences between IQbservable<T> and IQueryable<T> (mainly simplification)
• Extended role of IQbservableProvider compared to IQueryableProvider
• Synergy between IQueryable and IQbservable (ToEnumerable/ToObservable "sideways" conversion)
• What operators are available (answer: 99% - explain why that 1% is omitted)

Demo:

• Sample observable LINQ provider (LINQ to WQL)

Put your thinking caps on, turn up the volume, sit back, and learn. Erik Meijer and team are innovating at a level we haven't seen in a while around here. Rx is profoundly evolving and taking LINQ along for the ride. Incredible work!

Enjoy this latest episode of Going Deep. Ask questions. Bart et al. will answer them here and on the Rx forums.