people who havent really needs to watch barts pdc talk, its pure awsomeness

posted by aL_

Get all the related download materials for Bart's talk at http://microsoftpdc.com

C

posted by Charles

I like using asynchrony for exiting the monad, in particular what about this:

Sum: (IEnumerable<T> | IObservable<T>) -> Maybe<T> such that result: Maybe<T> : IObservable<T> where result.Count() = 1  (Z3 constraint)

Maybe use IQbservable perhaps...

Watching rest after (incredibly long iPad iOS update ..)

Edit: On second thought: the obvious name for Maybe<T> is not Maybe<T> it's of course:

MaybeLater<T>! 

posted by exoteric

posted by Charles

Love the explanation of Sudoku base theory.

posted by exoteric

also, i wonder if you could use the "let" keyword to define z3 symbols instead of using the ghost type:

from s in theoremcontext
let symbol1 = s.makesymbol<int>()
let symbol2 = s.makesymbol<int>()
where symbol1 > symbol2
select new {symbol1, symbol2};

in might be problematic because the "T" in Theorem<T> is defined in the final select, if you dont include all the symbols youve declared in the query, they woudnt appear in the proof.. still, the syntax whould be pretty nice

posted by aL_

posted by Richard.Hein

and Z3 rules, cant wait to see it get its way into more places as the core infrastructure of system platforms.

posted by felix9

posted by meta-commenter

4 minutes ago

This sounds interesting, I'd love to watch it. However, even the "Lo-band, Mobile" version is a 1GB download? You've got to be kidding...

In fact, the MP4 for mobile file is 420MB... No kidding.
C

posted by Charles

55 seconds ago

The MS Dutch Mafia strikes again!

Bart is from the Kingdom of Belgium, technically 

posted by Charles

posted by gbrayut

But what I am really looking forward to is LIM to "compiler service" when it comes out. It's going to be pretty cool to compose run time generated programs. And something tells me this is what Bart is secretly working on since his blog post about LINQ to Z3 is from April 2009

posted by Kyrae

Great, inspiring interview, btw.

posted by Novox

posted by bdesmet

Concerning Z3 versus Solver Foundation, I think the versus approach used for technology comparison is a little misplaced. Sure, there's some overlap, but Solver Foundation has its own strength and positioning in the market. Referring to it by its codename, "Optima", you should get some good insights in the kinds of problems it specifically aims to tackle. The target audience is also much further away from low-level software plumbers, more into the realm of business analysist (cf. its plug-in with Excel).

Once we make progress on (still hypothetical) Solver Foundation bridges using LINQ, I'll provide you with an update through the known channels .

posted by bdesmet

posted by bdesmet

Let's elaborate a bit on those points. First, even within the domain of querying, different data models or acquisition methods can give rise to other kinds of operators. For example, the push-based nature of IObservable<T> makes it a very natural candidate for signal-based programming where an observable sequence acts as a signal wire (e.g. TakeUntil). While it'd be very natural to expose such capabilities using language-integrated constructs, that may be a bit of a stretch as it goes beyond general purposing querying (which, till further notice, LINQ is about). Similarly, time-centric operators open up for a whole series of imaginary additions as well.

Personally, I do like the query comprehension syntax for the things it's good at. At some point, you'll for sure run short on the provided keywords (with varying mileage in C# versus VB, the latter of which has more keywords added for LINQ), but you can quite gradually "ease into" the dotting style of operator chaining (unless you have to insert between existing clauses, bad luck if you don't like some wholesale refactoring of the query expression).

Stricly speaking, you'd only need SelectMany (aka "bind") support ("do"-notation in Haskell, multiple from clauses in C#), to have all the power of monads at your service, assuming there are ways to "return" into the monad (e.g. new[] { value } for enumerables, Observable.Return for observables, etc.). Obviously that's too minimalistic (search for my project called MinLINQ to see this extremism in practice).

Finally, on the CaaS front, it's not at all sure at this point whether language syntax will be provided as an extensibility point, unless you can go in and extend the lexer and parser itself (causing you to create a new "dialect" of C#/VB altogether). Doing so definitely would limit the movements the benevolent dictators of the language design can take going forward ("oops, we may be clashing here with the 'bar' keyword introduced by customer 'foo' for the 'baz' dialect of C#"). The fluent nature of extension methods and the (relative, that is, without the support for "sectioning") conciseness of lambda expressions makes C# already a fairly good host for internal DSLs that follow an API-centric design. Popular patterns can always be lifted into proper language constructs, e.g. LINQ and the new "await" stuff.

posted by bdesmet

I'm personally from the area around Ghent (visit using Bing maps: http://www.bing.com/maps/?v=2&cp=sh8826h998kx&lvl=18.21744759896361&dir=2.693629766958403&sty=b&where1=Ghent%2C%20Belgium&q=ghent), so my accent is definitely Dutch, though I speak a bit of French and German as well.

posted by bdesmet

posted by bdesmet

posted by Batman

i'd love to see more blog posts and c9 content on expressions trees and how you can bend them to your will in the context of linq providers and other things.. Expression<Func<T>> is one of those things that i have a feeling is extraordinarily powerful but that i just barely know how to handle, but one wrong step i'd come tumbling down

z3 is even further down those lines, it seems almost like witchcraft, you ask it anything and it just replies with an awnser that is garantueed to be correct. you "just" have to be sure you ask it the right question

posted by aL_

Also, when Bart used the word "aspect" in his explanation of what a monad is, I was reminded of the following paper: On the relation of aspects and monads.

posted by ShinNoNoir

EDIT: i've managed to get a version of Bart's code to build/run against Z3 v2.15, but i don't think i can share it since i can't find a license on Bart's blog

posted by piersh

posted by contextfree

posted by bdesmet

posted by bdesmet

looking forward to it

posted by aL_

posted by parseval