jdk

Can you explain more about the .FixedPoint() linq method?  I found the naiad.pptx presentation with a lot of animations, but I'm unable to follow it without the narrative that I presume went with it.  I'll check out the paper, but if it's anything like this video, perhaps there are some prerequisite materials you can recommend?

From a practical standpoint, I'm interested in how to integrate this with a datasource like SQL Server for persistence.  To maintain a twitter-like service optimized for individual user/viewer queries, I assume that we'd have the data in an intuitive, application-specific schema of Users, Tweets, and Mentions.  As changes are committed to the persisted data store (SQL Server), we must independently notify the Naiad cluster of the change - and then the Naiad cluster members (or is it just the Controllers?) can service user queries quickly.  Is it advisable to allow this notification to Naiad to come from the database layer rather than from the application layer, using something like SQL Query Notifications?  Or does the high volume of changes that might be expected rule out Query Notifications?  The benefit of being able to listen to SQL Server directly for relevant changes would be relative transparency to existing applications, less chance of data getting out of sync due to a forgotten call to Naiad.

Alternatively, perhaps Naiad becomes the primary datastore and is augmented to persist its Dataflow dataset in a Naiad-friendly relational schema?

Amazing!  Really amazing!

This implementation is so well executed, I have a lot of confidence in Microsoft for this over Google.  The mental barrier to entry to this is so much lower than, say, Google Closure Compiler with this strong tool integration, attention to real-world concerns such as jQuery, etc interoperability, and a better syntax for type annotations.  Well done.

And my mind is totally blown by the slickness of the Playground code editor.

Brian writes on the board:

1. g: a -> Mb
2. f: b -> Mc
3. \a -> (g a) >>= \b -> (f b)

but it seems to me that one of two things must be true, either:

The "->" notation means something different in lines 1 and 2 than it does in line 3.  In line 1 and 2, "g is a thing (a function) with a type such that it takes a thing of type a and returns a thing of type Mb".  In line 3, I don't see how this same interpretation pattern fits over line 3, even with the grouping "\a -> [(g a) >>= \b -> (f b)]".

 OR, and more likely because I doubt he wouldn't have noticed:

They do mean the same thing but that there is some even more advanced meaning of the "->" operator, probably something to do with meta-types or kinds or something that applies correctly to each of the lines when understood correctly.

Or, maybe the question is, What is the Bind or Shove operator doing?  Is it sheding some metadata surrounding b or c in kinds Mb or Mc and returning the b or c type?  Is it de-generalizing a generic Mb or Mc kind??

Sorry, I went to public school but I'm really trying .

Maybe listing out how this functional or F# syntax is to be read would help as well.  eg.  "g: a -> a" is read as "g is a thing, a function, which takes a thing and returns a thing".  Even that may be incorrect.  Stay as general as possible.

You mention a great blog article by a Chris Broom in the video, but I'm unable to find it.  Do I have the name right?  Can someone post a link?

Thanks,

Jason