posted by GamlerHart

Great vid! LAtely when I want to view vids in full screen mode, I click on the expand icon on bottm left of video frame and the thing stops and goes black. I'm using a Dell Dimension laptop. XP latest SP, with latest Silverlight.

If I don't want full screen, all is fine.

Thanks!

posted by ACG

This is a known bug that we will fix!

C

posted by Charles

Good job Brian and Charles

posted by Chadk

C

posted by Charles

posted by mntb

posted by Charles

posted by exoteric

posted by Richard.Hein

posted by tomkirbygreen

posted by N2Cheval

posted by brianbec

posted by gav135

its awsome how general software design is.. i think people often think of "programmers" as people doing the same thing but its like saying all "engineers" or "scientists" do the same thing

-edit-

one thought on the "computer as a monad" concept, how does threading impact that way of looking at it? in a sense all threads share this state we call physical address space, does that break the comcept of the computer beeing a monad? im thinking is no longer functional because the state is sort of mutable from one compositional unit to the next. would love to hear brians toughts on that

posted by aL_

This idea is really "democratizing" to use Microsoft-lingo and we may call it embarassingly compositional.

Brian, are you thinking about remodelling the CLR semantics using monads to achieve a formalism for it?

We've already seen that IEnumerable<T> using yield can be used to model streams of computations that yield values (using statements or not),that these streams can be effectful and throw exceptions and that we can flip the control flow with IObservable<T> - both types with monadic operators associated with them; although they are not pure because effects are not captured as types and successively manifested as values of functions.

This time we hear the term "ambient monad" again. Is this a term coined within Microsoft is does it originate from the external world? It appears to be used by Brian and Erik in the Channel 9 videos and so at least reveals that Brian and Erik are using this term to think about computers/operating-systems (including the CLR).

I now recall that Erik call the .Net monadic operators "sequencing operators"; this makes sense if monads impede ordering, that is these sequencing operators are anti-commutative/symmetric and is of course very clearly manifested in IEnumerable<T> because it's inherently a sequence.

On performance. Brian has previously alluded to the fact that there have been two trends in computing: start with high-level declarative concepts and work towards performance or start with low-level imperative concepts and try to model abstract things using it. Both are unsatisfactory - at least until they bridge the gap but the functional programs are becomming closer to the dream of high-level declarative programming with high(est) performance and that any performance problem can be solved by a combination of improving the formalisms and the static analysis needed to simplify the program into the imperative machine code "equivalent". I like to think of Dependent Typing as an example of this, at least it has more precise (value) semantics and maybe also the potential for performance improvements. At least the dependently typed ATS programming language shows remarkable performance.

Interestingly, Microsoft has hired a very smart researcher who has experience with high-performance hybrid low-level/high-level programming language design, as well as operating-system construction. So we'll see where Microsoft is heading here in the future and what possible consequences this has for the CLR.

And appropos declarative vs imperative, I suppose one reason why this distinction is not so appropriate is because with monads, where ordering matters, the code is in a way "imperative", albeit in a very different way.

One might say that VB.NET and C# are in the middle here: they started with both declarative and imperative concepts and have moved up towards the declarative world.

By the way kudos on the production quality of this video.

There's some strangeness around the Silverlight player in bleeding edge Chrome release but I imagine that's a side-effect of just that, luckily by the magic of fiber and the speed of light, this is not an issue.

OK, enough editing. This post turned long.

posted by exoteric

\a -> (ma >>= \b -> mb). Since the dependencies are explicit in the program text, then can be decomposed by program-to-program transformations (aka "rewrites").

The "ambient monad" just means that side-effecting ordinary-looking compositions act exactly as if they were monadic Kleisli compositions in a State monad comprising the entire address-space of the machine.

You are also right that threads break down the dependency abstraction, therefore are "outside" the ambient monad. Suppose one thread computes function f, and another thread computes function g. With explicit compositions, monadic or not, you HAVE to write f(g(x)) or g(f(x)). If you just let threads go, you have no way of knowing whether f(g(x)) gets computed or g(f(x)) until after the fact . In pi-calculus, it's as if you wrote f(g(x)) | g(f(x)), that is, "hey, pick one of the two, I don't care which." It's not a monadic expression, although with pi we can get a precise semantics for it by embracing the non-determinism.

The plain truth is that the compositional style gives all kinds of practical engineering advantages like reusability, modulartiy, maintainability, reducing cost over time. The free-wheeling style give us all kinds of performance advantages, at the cost of compositionality. Both styles have their places. I am very fond of the idea of high-compositionality at the highest levels of abstraction where we need flexibility, and low-compositionality inside the VM where we need to squeeze value out of every cycle.

There are various ways of mapping explicit compositional dependency to time. One is lazy evaluation. Another is the "managed reference" machinery in Clojure. Another is the dual pair of IEnum* and IObserv*. They're all alive and healthy and loaded with possibilities.

posted by brianbec

posted by Charles

As a software assembler, I would like to see more declarative constructs in the programming languages to simplify complexity. Only having the two extremes that Brian mentions seems like only having two tools; the hammer and scaple. The electic drill, saw, etc. where you just press a button and it does stuff is rather useful as well. I would think once you have declaritive, you might be able to get around the problem of rewriting drivers... maybe.

posted by N2Cheval

posted by chrisnz

posted by Esther1

posted by Schneider

Actually while we're talking about that E2E interview, Brian also said that his goal was to ship The Brian Secret Project X before Erik shipped Rx. Well Rx is in .NET 4, which should RTM around the end of Q1 2010 right? Does that mean we're very close to having Brian reveal just what his Project X actually is?

posted by tomkirbygreen

posted by akopacsi