Comment Feed for Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx) (Going Deep on Channel 9)

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

evren12 — Thu, 26 Nov 2009 09:06:12 GMT

thank you :) very good share

Paylaşım Oyun İndir

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Nyi Nyi Thann — Thu, 19 Nov 2009 11:57:38 GMT

Apple[] as
Fruit[] fs = as
Fruit f = fs[0]
fs[1] = new Banana

In C#, the last line will throw ArrayTypeMismatchException. : (a)

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Benjol — Thu, 05 Nov 2009 06:32:13 GMT

Covariant/contravariant!

Help! Someone call Eric Lippert :)

Re: Re: Re: Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Dax Fohl — Thu, 22 Oct 2009 14:46:36 GMT

I'm wondering if given the excitement about the dual nature, we might be losing part of the intention of IObservable.

First of all, I'm thinking there might be a bit of a mismatch in the duality anyway. Primarily, IEnumerator and IEnumerable have a many-to-one relationship, whereas IObserver and IObservable havea many-to-many relationship, right? The deal is that IEnumerator has to have intimate knowledge about the structure of its IEnumerable that the app doesn't necessarily have; they're tightly bound. Whereas IObserver and IObservable are completely unaware of each others' internals.

I think the dual of IEnumerable would be something more like ILoadable, where you call ILoadable.GetLoader(), which then allows you to load values into an "array" or whatever, using Loader.MoveNext(bool) and Loader.SetValue(T). I certainly think the intention of IObservable is more valuable than any ILoadable concept (though ILoadable might be an interesting way to explore inserts and updates), so I wonder if the focus on duality is perhaps the wrong way to go about it.

For example, I'm not sure I get the point of the OnError method. First of all, isn't there a duality mismatch here anyway—given that IObserver.OnNext(T) could also throw an exception, then to preserve absolute duality going the opposite direction, shouldn't we require that OnError also be a part of IEnumerator? But beyond that, it just doesn't seem to fit. Why would the Observable need to tell all Observers that there was some exception downstream? Just like an iterator doesn't need to know that there's an exception occurring in the app that uses it. So I think the focus on preserving duality really mucks up the intention of IObservable in this case.

Also, I think if duality was that important to the concept of IObservable and IEnumerable, then the dual of (for example) IList would be even more powerful. But wouldn't the dual of (for example) IList.Set(int, T) be IListDual.Get(out int, out T)? Is that useful in some fashion? I don't see anything, though I'd love to hear from anyone with an idea how it could be powerful.

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Bent Rasmussen — Mon, 07 Sep 2009 16:17:41 GMT

I was quite happy with the coverage - it was already unusual to mix physics and programming this way - very stimulating although beyond me. One of the best parts was the formulation of co- and contravariance rules via sequent notation, dualization and showing a statement sequence as a series of continuations, if I got that right. Definitely a video that expands horizons. And this stuff about ambient monads. I'm not sure that was really covered anywhere, was it?

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Keith Dahlby — Wed, 02 Sep 2009 03:38:16 GMT

For what it's worth, a solution to the deferred disposal problem can be found here: Using IDisposables with LINQ. The filestream example would look like this:

IEnumerable<string> lines =
    from fs in new Stream("...").Use()
    from l in fs.ReadLines()
    where l.Length > 256
    select l;

foreach(var l in lines)
{
    // fs will be disposed with the enumerator
}

The same approach can be used with a delegate to defer creation as well as disposal: () => new Stream("..."). A use keyword, a la F#, would be even better.

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

brianbec — Sun, 23 Aug 2009 18:03:36 GMT

I was also unhappy about the covariance / contravariance discussion, so I'd like to work something up for ch9 for the near future.

I did peek at my old physics notes, and here's the gist from physics. Consider a parametric curve, meaning a function p(t) from a real-valued parameter, call it t, to abstract geometric points p in some space M. In calculus on manifolds, we learn that such points have various coordinate systems -- functions from abstract points p to n-vectors of real numbers (x1(p), x2(p), ..., xn(p)), such that we have differentiable functions from each coordinate system to all the others around every point. That means we can always identify abstract points p with n-vectors of real numbers, (x1(p), x2(p), ..., xn(p)) -- the coordinates of the point, in various ways -- say another set is (y1(p), y2(p), ..., yn(p)), so that the derivatives dxi/dyj and dyj/dxi exist (where i and j vary from 1 to n, inclusive).

Now consider a function f(p) from the points p on the manifold to something else (usually some other real vectors but it doesn't matter). What happens with df(g(t))/dt when we change coordinate systems? By the chain rule, df/dt = sum(i=1..n, (df/dxi)*(dxi/dt)). But

1) df/dxi = sum(k=1..n, (df/dyk)*(dyk/dxi)) -- a.k.a. covariant co-vector

2) dxi/dt = sum(l=1..n, (dxi/dyl)*(dyl/dt)) -- a.k.a. contravariant vector

Quantities that vary in the same way as df/dxi are called co-vectors and are covariant. Here's a mnemonic. Abbreviate df/dxi as f,xi and automatically sum over repeated indices. Rewrite equation 1 as

f,xi = f,yk * dyk/dxi. See the y's "upstairs" in the dyk/dxi on the right-hand-side? UPstairs means COvariant. Now look at equation 2 -- abbreviate dxi/dt as x.i :

x.i = y.l * dxi/dyl. See the y's "downstairs" in the dxi/dyl on the right-hand-side? DOWNstairs means CONTRAvariant. Such things are called vectors.

Ok, now how we turn these relationships amongst Coordinate Transformations into relationships amongst Types and Subtypes would be the questions I would ask to draw an analogy between co/contra variance in physics and co/contra variance in programming languages.

Ideas anyone? Can we relate types and subtypes to differentiable coordinate transformations? Is the "type" of an object similar to the "coordinates of a point?" Can the derivatives of the coordinate transformations (dxi/dyk) somehow be related to type coercions?

Re: Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Charles — Sat, 22 Aug 2009 01:19:54 GMT

Indeed. They were addressing the new additions to C#...

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

DouglasH — Fri, 21 Aug 2009 07:38:45 GMT

I think they were implying the work done around co and contravariance in C# 4.0. Could be wrong though.

Douglas

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

coolpun — Wed, 19 Aug 2009 05:56:26 GMT

Wow. Were they way off on the covariance and contravariance example earlier in the video. Btw, the array covariance in c# is broken, and it was never legal (or wise) to have a Apple[] have a Fruit[] as the backing storage. Erik was plain wrong on that being safe. Anyhow, a cool vid otherwise.

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Charles — Wed, 19 Aug 2009 01:29:29 GMT

Absolutely. And I've been meaning to vist Yuri again. Yuri has many great things to say. He's brilliant. Erik, Brian and Yuri. Yes, I LOVE the sound of that.

We're very lucky that Brian and Erik are both HUGE fans of Channel 9 and the Niner nation! :)

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

sla — Tue, 18 Aug 2009 15:49:30 GMT

Awesome!

Can we please have more of Erik with Brian together.

Let them discuss varinats in type system or other academic stuff. Or mroe real life MSR projets, for example spec#, spec explorer, axum etc.

Maybe someday you can get Yury Gurevich and Tony Hoare together :)

Thanks Charles, awesome video.

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

dbaechte — Wed, 12 Aug 2009 22:57:18 GMT

Did you forget something?

The Subsrciber to the Observer assumes that the Observer, and the connection to the Observer, are functional during the life of the subscription. If the Observer, or the connection to the Observer, fail, the Subscriber may never know and assume that all is well when it is not. What happens to the Subscriber if the Observer, or the interface to the Observer, fail? How is that handled?

Are other features required so that the Subscriber can periodically verify the health of the Observer and not blindly assume that everything is OK when no events are received ?

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

JeffVa_MS — Wed, 12 Aug 2009 00:28:22 GMT

If you're interested in a nice challenge with Rx, go over to my blog and try solving the tripple-click puzzle:

http://blogs.msdn.com/jeffva/archive/2009/08/11/fun-system-reactive-puzzle.aspx

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Chris H — Fri, 07 Aug 2009 16:06:08 GMT

I would just like to ask, since Erik mentioned that this IObservable captures the essence of a Continuation, does that mean something like call-with-current-continuation could be implemented in C# using the IObservable?

I am not very familliar with C#, and I have never fully grokked call/cc, so bear with me if this question is lacking some basic fundamental understandings of either!

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Radoslaw Jedrasiak — Tue, 04 Aug 2009 23:12:38 GMT

A little brainstorming after having watched the video:

S1 ; S2

In the language of event-driven/reactive paradigms this could be read as: statement 2 is one observer of the state manipulations done by statement 1... now guys hold on to your brains: what happens when there is more than one observer to S1? The whole idea of one statement after another "breaks" as S1 is followed by S2a and at the same time by S2b and S2c etc.etc. S2a, S2b S2c etc all get notfied and start executing at the same time... A program transforms from a list of statements into a tree of statements? Parallel computing? Speculative computing? Quantum computing?

It is deeply (almost disturbing and) fascinating to see how IObserver actually covers the continuation monad, which more or less seams to be the essance of "statement after statement with shared state" programming. One statement tells the next to execute or communicating an error or the end of the program.

Another twist: what happens when one statement S2 can get hold of the handle connecting/making it the succesor of S1 (the IDisposable obj) .... statements reconnecting? Programm-parts actively rewireing based on meta-state?

How about not using IDisposable but instead an extended "handle" allowing not only to stop the subsription but also to interrupt (for certain time?) or control it otherwise? (have to admit i did not check out the code yet, maybe that is already available)

And the last for today: what other dualities are there waiting to be found? ;)

Re: Re: Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

head.in.the.box — Mon, 03 Aug 2009 17:04:59 GMT

http://community.schemewiki.org/?amb

Re: Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Allan Lindqvist — Thu, 30 Jul 2009 19:49:59 GMT

it was actually :) im having som compilation issues when using it with a regular .net project though, most likely because its a silverlight dll. also, i cant wait to hands on some docs, what is the Amb extension method for example? and does Rx use tpl for synchronization?

questions, questions.. :)

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

head.in.the.box — Wed, 29 Jul 2009 16:10:01 GMT

Isn't that a nice surprise :-)

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

head.in.the.box — Wed, 29 Jul 2009 16:09:21 GMT

Once you tier-split a computation to run across tiers, you *must* solve the asynchronous programming problem. If you remember, our previous release used callbacks for asynchronous calls.

Rx is the fruit of our efforts to come up with a general model of asynchronous computations that applies to a wide range of scenarios, including tier-splitting.

Wow, that sounds like a marketing pitch, but it is actually technically accurate.

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Edmondo Pentangelo — Wed, 29 Jul 2009 11:30:56 GMT

Is RxLinq part of the Microsoft Tesla long term initiative ?

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Allan Lindqvist — Thu, 23 Jul 2009 14:09:27 GMT

rx has apparently made it into the silverlight toolkit :)

http://themechanicalbride.blogspot.com/2009/07/introducing-rx-linq-to-events.html

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Edmondo Pentangelo — Wed, 22 Jul 2009 23:15:00 GMT

Just for the fun of it,

I've added an F# implementation of SelectMany and Select for IObservable in F#.

http://reactivelinq.codeplex.com/

holoed

http://fsharpcode.blogspot.com/

Re: Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Charles — Sat, 18 Jul 2009 01:33:48 GMT

Nope. This hasn't shipped yet. :)

But it will.

Re: Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

jzli — Sat, 18 Jul 2009 00:31:00 GMT

I didn't see any announcements about this, so forgive me if this is a repost, but has this accidentally (or perhaps intentionally?) shipped with the Silverlight Toolkit?