Expert to Expert: Erik Meijer and Butler Lampson - Abstraction, Security and Embodiment

Nice conversation.

Well I am sure that both Bulter and Erik know about Windows SteadyState, but it is exactly the implementation of a "red" machine that can allow "credible" state changes by credibel sources, i.e. Microsoft update or an Admin, but returns back to a "steadystate" after a user is finished using it.. 

http://www.microsoft.com/windows/products/winfamily/sharedaccess/whatis/default.mspx

Even if you ran a browser you would want to update the "kernel" since the OS always needs to mutate the state to update... Unless you are done on day 1..

Thus, the steadystate is a clear example of a system that allows explicit mutation by a credible source, Microsoft Update or Admin, but is also has an immutable "bubble" that the user lives in.. More along what Joe Duffy has in mind.. Bubble of mutability and bubble of immutability

This was a really awesome video.

I literally did a spit take when you guys started talking about browsing porn! Looking forward to Butler's Embodiment talk, and thanks Charles and Erik for another great interview!

Perhaps Butler has solved the CoffeeHouse spam problem.  Put a link on each post that is redeemable as a charitable donation to the salvation army. If the post is spam, redeem it.

No you need more of that. I want to see toilet humor in future videos also.

Its always good to see an interview with a Turing Award recipient.  Good interview guys.

The paper on lazy evaluation doesn't seem to be available online - the version from the ACM Portal (74kb) is only the abstract and not the paper itself..

I saw him give that talk at last year's ICFP!    It's not really a research paper, more of a stimulus to thought.

Excellent Video, more of Butler in the future please, he's a real intresting person.

Good discussion! I like these deep discussions, it’s not Butler’s first clambake, he has pretty much been there done that. Glad to see Microsoft brings this talent into the company, this stuff can’t be learned quickly in a classroom, it needs years of practical experience.

I do tend to agree with Erik about the layers on top of tcp/ip. Tcp/ip is a good reliable architecture, similar to putting stuff in a truck. The driver will get to the location required, doesn’t care or know what the cargo is but it will get to the destination. If you look at what sets on top of tcp/ip it is mostly ascii human readable text. Seems to be a waste of bandwidth, why not send binary. I have done some .net socket programming with network streams, at least to me seems more efficient.

More of these interviews would be appreciated, too much knowledge not to be available.

Charles and Channel 9'ers I actually believe I found that magic sauce/Silver Bullet/Free Lunch for concurrency & parallelism for running sequential programs in a concurrent manner on a multi-core chip.

 In no relation to relativity, I call it Relativistic Computation, I'm in school so time is limited.  But for relativistic computation I just mean when code gets pumped into a scheduler, in a sequential way, its functions are put into a CPU opcode pipeline, and when the function hits and goes over all the cores, flowing over to start on the first core again, it reassess the function to execute based on its progress over the available array of cores.

A data dependent Increment to 40 showing what number goes where during each step to look like:

Step #: 01 - 02 - 03 - 04 - 05 - 06 - 07 - 08 - 09 - 10 
————————————————————————————————————————————————— 
Core 1: 01 - 05 - 09 - 13 - 17 - 21 - 25 - 29 - 33 - 37 
Core 2: 02 - 06 - 10 - 14 - 18 - 22 - 26 - 30 - 34 - 38 
Core 3: 03 - 07 - 11 - 15 - 19 - 23 - 27 - 31 - 35 - 39 
Core 4: 04 - 08 - 12 - 16 - 20 - 24 - 28 - 32 - 36 - 40 

Even though it looks plainly obvious it has never been implemented!!  Just have an input and output scheduler pump dependent opcodes sequentially into separate CPU pipelines to saturate the separate core pipelines.

Basically, it's striping a STREAM of assembly opcodes into the CPU's after the scheduler has a quick data flow analysis for it to make the recomputed true op/function running be +4 per core instead of the original +1 for each core in that example to show the concept at work.

The scheduler being huge in controlling data access to and from both input/outputs of the data streams to help control conditional execution and data dependancies; so having  1 scheduler to control 1 chip and its cores in a User-Mode Scheduler(UMS) or a VM abstraction for memory isolation would be quite awesome.

Id really enjoy a respectable Microsoft Technical Fellow to see if this is even sensible but it seems to work in my head  

This is my first post here but I am a long time channel 9'er and avid Haskell enthusiast thus it's nice seeing Erik being challenged by such a guy like Mr. Lampson.

Until next time Charles 

I have a better idea.

Why not replace English with some highly compressed machine friendly language? You'll save a lot of bytes.

But seriously, it's not like the human readability of HTTP sacrifices massive amounts of bandwidth: the commands are really short, like "GET". You'd probably implement that with a 1-byte opcode if you did it in binary, saving a whooping 2 bytes. For losing human readability, it's not worth it (imo).

Bass,

Agreed, may not save much on simple commands. But sending binary gets expensive with XML Schema type base64binary if you need to use it. I have used it with Soap web services, works but you take a hit in bandwidth. To be honest I am just getting deeper into web programming so I don’t know all the pluses and minus. I would rather program WPF or Win form GUI’s any day over HTML, just my opinion.

From what I have read base64binary is popular with many mobile portal operators sending pages with images even with the up to 33% more bandwidth hit since they can render everything on one server hit. Supposedly Google's iPhone homepage does this for speed. Seems like pure binary would be even faster, but apparently you can’t do it in HTML without base64 or going back for multiple server hits.

Great interview Charles, I love the Expert to Expert series - almost without exception each video I've found myself watching or listening to multiple times - they're so filled with interesting ideas and unexpected engineering tangents.

With regard to transactions and kernels, would applying STM to Singularity be a worth while effort? Is Singularity considered 'general purpose' enough? It wasn't clear to me if the actual definition of general purpose was meant to mean: able to run a existing binary?

One interesting thing I noticed in this regarding threads and how they don't work for concurrency, whilst true I wonder if the abstraction of a thread (a task) is something we can understand.. it seems to me the problem with needing to manage threads is their directness.. tasks which abstract needing to manage threads and let me worry about synchronization is a good step towards solving the problem.. the next steps perhaps about how we can automate synchronization.. such that the compiler or runtime can reason where tasks can be generated and automatically handle the synchronization for me.

Since theres such a great theme of abstractions in this talk (and the initial points about just HOW many abstractions we are on (all the way down to even the atomic / quantum? world)) is something I've thought about before when attempting to reason the need for certain abstractions.. I would like to think we get to a point where we say less about how our application explicitely wires up, and just set expectations (similar to linq), which the compiler/runtime can automatically reason about and manage an execution plan for me.. this way the concurrency problem not only isn't harder for us to write, but perhaps even easier because we write less.

2c

I can't decide if this is a joke or are you actually suggesting implementing something like this?

Thing is, this would not work well at all, in fact your 4 core example would work much slower, if at all, than just running all the code on 1 core.

The issue is concurrent memory access. By definition the 4 cores would run at the same time, and in your example it is an increment by one opcode. Well, all four cores would get the value of 01 and change it to 02. And in the next step all the cores would have 02 as the value and increment it to 03. Actually this is even an oversimplified situation, in reality core 2 for example might finish earlier than others because it runs at a higher clock rate and thus will get ahead of the other cores.

Now you might say that: "But there are atomic instructions available!". This is true for some instructions, but they are much slower. The CPU would be constantly hitting L3 cache, or even worse - RAM. The cores do not share the same low level cache, so if you modify some data, the change won't show up on other cores unless you push the change back into higher level memory, like L3 cache or RAM.

impressive, I like this special episode. Thank you for sharing this video.
[url=http://www.freerpgsite.com/]free rpg games[/url]