Jules.dot

• Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask)

  Apr 10, 2012 at 3:17 AM

  Very interesting video. I do wonder about one thing: you do not say anything about what happens inside an actor, except that it is deterministic. Since interacting actors can be indeterministic and a single actor cannot be indeterministic, a single actor cannot be made out of other actors internally. This raises the question: with what granularity should you model your system with actors? You could do it very fine grained, where each individual number and data structure is an actor, but this leads to massive undesirable indeterminism. On the other hand, you don't want to model your entire system as one single actor, because that is not scalable. If you modeled your system with X amount of actors, but suddenly we get Y>X cores, then you need to redesign your system to take advantage of them, which is also not desirable. What we want is a way to get deterministic results but a variable amount of parallelism. It seems that the actor model does not really say anything about this, though perhaps something can be built on top of it?

• Defrag: So You Just Got a New PC

  Jan 04, 2012 at 12:58 PM

  While I'm still watching the video I just have to say: Ninite!!!

• Simon Peyton-Jones and John Hughes - It's Raining Haskell

  Dec 25, 2011 at 2:40 PM

  Two awesome guys. Is SPJ's keynote going to be posted online?

• SPLASH 2011: Sam Tobin-Hochstadt - JavaScript Modules

  Nov 23, 2011 at 6:34 PM

  Nice interview; it's a pity that it's so short. He has done some very interesting research on typed scheme and contracts. I hope we'll see some of those results appear in future versions of Javascript.

• SPLASH 2011: William Cook - Objects, Orc, Hybrid Partial Evaluation, and More

  Nov 22, 2011 at 8:27 AM

  If mr. Cook is reading this: how does multiple dispatch and predicate dispatch fit in the picture of OOP/ADT?

• .NET 4.5: BCL Team - Improvements and Evolution

  Nov 10, 2011 at 5:12 PM

  Actually, you can have a List that is both covariant and contravariant by giving it two type parameters: List<out Read, in Write>. Then you use the right type for each method. For example Add(Write elem) and list.First has type Read. Now you can pass a List<string,string> to a method that reads objects from that list, and pass a List<object,object> to a method that writes strings to that list.

• SPLASH 2011: Gilad Bracha - Dart, Newspeak, and More

  Nov 09, 2011 at 2:16 PM

  Great!

  I wonder if there's any chance to have Erik and Gilad in an interview together about Dart and whatever else comes up...

• Announcing Python Tools for Visual Studio 1.1 Alpha

  Nov 04, 2011 at 5:53 AM

  Very good work! I use Python Tools a lot and it is awesome

  Any plans to infer generic types too? That way you'd have the example with the function foo that just returns its argument infer the string methods for foo("bar") and the integer methods for foo(42), even if you have both in the same file. Languages like F# already infer types that way, perhaps their algorithm could be adapted.

• CLR 4.5: Maoni Stephens - Server Background GC

  Sep 23, 2011 at 3:35 PM

  Cool stuff. It would be awesome if you could really go into the workings of the garbage collector in one episode. I mean explaining what the GC algorithm is doing on the whiteboard with pseudo code.

• Guido de Caso - Distributed Knowledge Authorization Language

  Jul 28, 2011 at 1:48 PM

  How is this related to logic programming? It seems like this is logic programming where variables can appear in more positions: in positions where a predicate can appear, but it cannot have arguments. 

   

  X :- said(alice,X).
  said(alice,workshere(bob)).
  
  hasaccess(P) :- workshere(P).

  This makes me wonder if it would be possible to implement a system where the "variable predicates" could also have arguments, like:

  X(Y) :- foo(X,Y).

  And whether you can also add predicate applications on the right hand side that are variables:

  foo(P) :- P.

  You can do this in Prolog with call/apply but perhaps it would not interact well with having the variables on the left hand side.

   

See more comments…