Entries tagged with programming - Channel 9

C9 Lectures: Brian Beckman - Covariance and Contravariance in Physics 1 of 1

Charles — Wed, 25 Nov 2009 18:22:00 GMT

By now, you know Brian Beckman given how many times he's been featured on Channel 9 and, well, just how amazing he is. Brian is an astrophysicist and software architect currently working on a technology we can't talk about...yet... :) Stay tuned for that. Dr. Beckman is the perfect choice for a new lecture in the C9 Lectures series. This is a single lecture, but there will be more interesting conversations to come on this deep and beautiful topic (in some sense, this is all about symmetry).

In the Rx interview with Brian and Erik Meijer, a short discussion on covariance and contravariance took place as a tangential topic (which often happens in real conversations - and we love that!). The concepts of co/contravariance can confuse and confound. Also, they are not just related to programming.

Here, Dr. Beckman teaches us about covariance and contravariance in physics. Are these universal properties? Do they apply to the mathematics of physics (from quantum mechanics to black holes) in the same basic way they do for general purpose programming with objects and lists, for example?

Tune in. This is a deep dive lecture and quite mathematical. Don't be scared. As usual, Brian explains complex things in a readily understandable fashion for mere mortals. If you have no experience with math and physics, this may be a bit challenging, but certainly not entirely over your head.

Enjoy.

NOTE: You should download the supporting document and slides. This will help you learn faster!

Getting Started with Rx Extensions for .NET

Charles — Tue, 17 Nov 2009 20:57:00 GMT

Reactive Extensions for .NET, Rx, is here!!!

Reactive Extensions team member and software developer Jeffrey Van Gogh shows us how to get started with Rx, how to install the bits, find the help documentation and add Rx into your visual studio project - all in 2 minutes!

Erik Meijer: Rx in 15 Minutes - Rx is Here!!!!!

Charles — Tue, 17 Nov 2009 20:53:00 GMT

Reactive Extensions for .NET, Rx, is here!!!

Erik Mejier explains what Rx is and why it matters in 15 minutes or less!

E2E: Erik Meijer and Patrick Dussud - Inside Garbage Collection

Charles — Fri, 13 Nov 2009 16:30:00 GMT

Patrick Dussud is a Technical Fellow at Microsoft who is the author of .NET's garbage collector (GC) - the automatic memory management infrastructure that makes up most of what is managed in managed code execution. How does GC, work, generally? Why is it important? The GC inside of the CLR is of a specfic type - ephemeral, concurrent (the server version has always been concuurent and now with Background GC on the client in CLR 4, GC is concurrent on the client as well, but there are differences...).

Patrick takes us through the basics of GC up to the current state of the art in this outstanding conversation with one of the fathers of .NET. Of course, given the other expert in the room - programming language designer Erik Meijer, we have to talk about the impact that dynamic and functional languages have on the design of general purpose GCs as well as future directions of the CLR's GC, generally. What's Patrick working on these days?

Patrick will be presenting at PDC09 in the the Technical Leaders track. His talk, Future of GC, should not be missed. This conversation is a great introduction to what Patrick will be talking about and we highly recommend you watch this before you attend his session (or watch his session after the show shortly after the PDC ends - like last year, all sessions will be available on-demand...).

Enjoy.

Windows Embedded: Past, Present and Future

Charles — Thu, 12 Nov 2009 21:14:00 GMT

Windows Embedded Standard is a general purpose OS, based on the Windows codebase, that is highly modular and fine tuned to run on a number of devices ranging in size and complexity (but less powerful and kess general purpose in nature than your average PC) that are x86/x64 powered (casino gaming consoles, retail kiosks, hand-held devices, etc). The next version of Windows Embedded Standard will arrive some time in 2010 - thus the name Windows Embedded Standard 2011.

Windows Embedded is the general term for all Windows embedded products including Windows Embedded Standard, Windows Embedded Compact (aka CE), Windows Embedded Server, Windows Embedded Enterprise.

For the Windows Embedded Standard product line, product examples are Windows XP Embedded (aka XPe), Windows Embedded Standard 2009, Windows Embedded Standard 2011, Windows Embedded POSReady 2009.

We figured it would be a good idea to meet some of the developers who write Windows Embedded Standard to get a better understanding of, well, exactly what it is and where it is going. Here, we meet and chat with Windows Embedded Standard developers Oren Winter, Jon Parati, Mike Moini and Milong Sabandith. What are the key new features in Windows Embedded Standard 2011? What is Windows Embedded Standard 2011, exactly? What's Windows Embedded CE, again? How is Windows Embedded related to Windows proper? Windows Embedded Standard 2011 is built from the same sources that make up Windows 7? What's different between the two and why? How is Windows Embedded Standard able to be so modular? What's the developer story for Windows Embedded Standard 2011? And more. Tune in. Classic Channel 9.

Useful Links:
Product Overview
CTP Download
Submit Feedback
MSDN Forums
Team Blog
Webinars

C9 Conversations: Yousef Khalidi on Cloud Computing

Charles — Wed, 11 Nov 2009 00:46:00 GMT

Yousef Khalidi is a Distinguished Engineer with a rich history in both operating system design and distributed computing. Yousef is responsible for the overall design of Windows Azure, Microsoft's cloud operating system (which includes the Azure development platform in addition to the "OS", aka Windows Azure). Windows Azure is an operating system in the sense that it supplies a host of core services, process scheduling and management, identity management, etc, that we typically expect from a general purpose operating system.

In this first installment of C9 Conversations (we sit down with various Microsoft technical leaders to discuss a wide range of topics related to general purpose computing; all in high quality video and audio (big thanks to Tina Summerford for producing this new series)), the topic is cloud computing. What is it, exactly? Why does it matter? What are the challenges involved in taking software to the cloud? What does that mean, exactly? Is Windows Azure an operating system by analogy? What is Windows Azure, exactly? And more..

Yousef will be presenting his ideas on cloud computing and its future at PDC09 as part of the Technical Leaders track. Make sure to attend his talk if you're interested in how Microsoft thinks about the future of cloud computing.

Niners on 9: Sven Groot - Past, Present and Future

Charles — Wed, 07 Oct 2009 20:25:00 GMT

Sven Groot is a long time Niner and one of the more active contributors to the C9 forums (you'll note that Sven answers technical questions when he can and has always been respectful in the way he interacts with his fellow Niners). Sven is also a PhD student at Tokyo University where he is working on and thinking about large scale distributed clustered computing (now we know why he was so keen on my producing a Dryad piece for Going Deep - Sven is a clever guy...).

Sven was in town recently on vacation in Seattle (why not Maui or one of the Tahitian islands, man?), so we had to interview him. Also, I brought Sven to a randomly generated team meeting of one of the most innovative teams at Microsoft (and filmed it). So you will see more of Sven and learn more about some very interesting technologies, but here we learn all about Sven, the man, the legend.

We cover a lot in this impromptu conversation and Sven has many interesting things to say about cloudy computation and the future of distributed computation somewhere up there. It's great to have you as a vocal member of Channel 9, Sven. Thank you for the feedback on C9 (some of which is shared in this conversation) and for being helpful to your fellow Niners. See, Niners, when you come to Seattle, you never know if you will sit down in front of a camera, rolling 9.

Enjoy and thank you again, Sven!

Expert to Expert: Rich Hickey and Brian Beckman - Inside Clojure

Charles — Tue, 06 Oct 2009 17:29:00 GMT

Clojure is a dynamic programming language created by Rich Hickey that targets both the Java Virtual Machine and the CLR. It is designed to be a general-purpose language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language - it compiles directly to JVM bytecode, yet remains completely dynamic. Every feature supported by Clojure is supported at runtime. Clojure provides easy access to the Java frameworks, with optional type hints and type inference, to ensure that calls to Java can avoid reflection.

Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.

Astrophysicist and Software Architect Brian Beckman interviews Rich Hickey to dig into the details of this very interesting language. If you don't know much about Clojure and the general problems it aims to solve, well, watch and listen carefully to this great conversation with plenty of whiteboarding and outstanding questions. Expert to Expert simply rocks! Thank you for spending time with us, Rich! Clojure is great!

E2E: Erik Meijer and Wes Dyer - Reactive Framework (Rx) Under the Hood 2 of 2

Charles — Mon, 28 Sep 2009 15:50:00 GMT

Software Developer extraordinaire and language compiler geek Wes Dyer and programming language design guru and LINQ co-creator Erik Meijer dig into the Reactive Framework (Rx). This is part 2 of 2. See part 1 here.

Here, Erik and Wes continue their discussion on the core ideas behind Rx. Rx is deep (as in profound), as you must have gathered by now. Erik, of course, continues to keep the theoretical basis of all this squarely front and center so we understand the relationship between principles and practice.

Enjoy!

E2E: Erik Meijer and Wes Dyer - Reactive Framework (Rx) Under the Hood 1 of 2

Charles — Mon, 28 Sep 2009 15:47:00 GMT

You've already learned a great deal about Erik Meijer's latest programming creation, Rx, right here on Channel 9 (here and here, to be precise).

Well, wouldn't it be great to get the two key minds behind Rx in one place with one whiteboard? Yes, of course it would! Enter Software Developer extraordinaire and language compiler geek Wes Dyer and programming language design guru and LINQ co-creator Erik Meijer to dig into the "Live Labs Reactive Framework (Rx)" or ".NET Reactive Framework (Rx)". So, let's be honest here. The official name of this great technology has not been determined. But, it's just a name and the name is so much less interesting than what this technology enables and will enable in the future for software developers. So, forget about the exact branding of Rx. Just think of it as, well, Rx until the marketing people come up with an official naming scheme (that most likely will not be as cool as Rx, but c'est la vie...).

Here, Erik and Wes focus on the core ideas behind Rx and dig into the geeky details of this observer-based programming model. Rx is deep (as in profound), as you must have gathered by now. Erik, of course, keeps the theoretical basis of all this squarely front and center so we understand the relationship between principles and practice.

Enjoy!

Announcing Windows 7 Developer Boot Camp at PDC09 (and it's free!)

Charles — Wed, 23 Sep 2009 17:19:00 GMT

We just announced a day of free training on November 16, 2009 in LA as part of PDC09. Did I mention that it is free, that it will include deep dives into the depth of Windows from folks like Mark Russinovich, Landy Wang and Arun Kishan? Wait, did I just write that?!

This is AWESOME. If you are a Windows developer and in the LA area I would highly encourage you to attend this free day of training.

The event is FREE to any one, it does not matter whether you are attending PDC.

The event is first-come-first serve and there is limited capacity, so sign-up early!

The event will be fast-paced and very dense; we are condensing several weeks worth of blog, documentation and code reading into 8 hours... It truly is a great way to dive quickly into Windows 7. Going Deep in real time! :)

The event is coordinated with other PDC sessions, we aim to minimize overlap, and make sure there is good segues from the boot camp to PDC sessions.

There will be more speakers announced next week. Stay tuned!

Instructions for PDC09 conference attendees. Enter the regular registration process through the Registration page, and click on the orange register now button. Select ‘register for the event’ as your registration type. You’ll be able to add the Boot Camp as a workshop during the registration process. If you have already registered, simply login and update your registration record to include the Boot Camp.

Instructions for non-attendees. Enter the regular registration process through the Registration page, and click on the orange register now button. Select ‘register for workshop only pass’ as your registration type. When you get to the workshop selection page of the registration form, you'll be able to pick the Windows 7 Boot Camp as a free item.

Andrew Kennedy: F# Units of Measure

Charles — Tue, 22 Sep 2009 21:00:00 GMT

Floating point values in F# can have associated units of measure, which are typically used to indicate length, volume, mass, and so on. The built-in type float takes an optional unit-of-measure parameter, written in angle brackets, in a similar way that types such as IEnumerable take a type parameter, as in IEnumerable<int>.

By using quantities with units, you enable the compiler to verify that arithmetic relationships have the correct units, which helps prevent programming errors like the one that led to NASA's Mars Climate Orbiter being lost in September 1999. This was due to confusion between metric and so-called "English" units of measurement. The accident could have been prevented if the NASA engineers had been able to annotate their program code with units, and then employed static analysis tools or language-level type-checking to detect and fix any unit errors.

Andrew Kennedy is an MSR research scientist who implemented units of measure for F#. What did this involve? How does it work, exactly? What's next? Meet Andrew and learn all about F#'s latest language feature, units of measure.

Enjoy.

Information sources: http://msdn.com and http://blogs.msdn.com/andrewkennedy/

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

Charles — Thu, 17 Sep 2009 16:09:00 GMT

This is a very special episode of Expert to Expert. We were very fortunate to get some time with renowned computer scientist and Microsoft Technical Fellow Butler Lampson. Butler's impact on general purpose computing is profound. Personal computing as it exists today is in part the result of the great work done by Butler over the past 30 years.

Programming language designer and high priest of the lamda calculus Erik Meijer hosts this episode of E2E and Erik and Butler cover a very wide swath of computing topics. It's simply beautiful and very deep geekiness. In fact, this is one of my favorite Channel 9 conversations of late. I know you will enjoy both the usual real conversational aspect of this and the depth of historical insight into some of the core aspects and unresolved problems of general purpose personal computing.

Go get some popcorn, stream this into your XBox or Media Center and learn from one of our industry's pioneers who still has a great deal to offer to the world of personal computing. What's Butler working on these days, you wonder? What's top of mind for him as it relates to today's biggest challenges in computing? What does software security really mean? How many levels of software abstraction do we need? Why is data synchronization such a hard problem? What is software embodiment, exactly (Butler will be presenting his thinking on software embodiment at PDC09, as part of the new Technical Leaders track (something yours truly is responsible for - I hope you plan on attending these very special sessions and if not you will be able to watch them right here on Channel 9))?

Tune in and meet a true legend in our industry. Microsoft is very forunate to have Butler Lampson thinking about some of the hardest problems we face as an industry and ensuring that Microsoft is capable of tackling these challenges in a way that extends the solutions for long term relevance in a changing and unpredictable environment.

Inside Windows 7: RADAR - Windows Automatic Memory Leak Detection

Charles — Tue, 15 Sep 2009 15:29:00 GMT

RADAR is a memory leak detection technology built into Windows 7 and integrated with Watson (error reporting) and AutoBug (automatic bug filing). It allows Microsoft product teams and third parties to discover and fix memory leaks early in the product cycle and after release. Since RADAR runs on customer machines, leaks can be caught during public betas, after release, and by third parties, thus ridding the entire ecosystem of memory leaks. RADAR-shipped components are highly optimized to have no appreciable performance impact.

Meet RADAR developers Stephan Doll, Baskar Sridharan, Anthony Lorelli‎ and Keshava Subramanya. They dig into the architecture, design and implementation of this great technology. RADAR helps make Windows more reliable and stable by automatically pinpointing memory leaks in code that are then packaged up in bug reports that land in the hands of developers responsible for the memory leaking code. This means quicker to market solutions and knowledge gain that will prevent the same bugs from cropping up again: developers learn what went wrong and why so wthey won't make the same mistakes again. You'll learn about the most common mistakes made and you should use this to prevent memory leaks in your own native code.

Tune in. Learn.

Parallel Performance Tuning for Haskell

Charles — Sat, 12 Sep 2009 19:30:00 GMT

Very interesting work with implications for integration into more mainstream runtimes... In general, runtime support for parallel tuning is necessary going forward. The Many Core age has only just begun... This paper is a great read.

Parallel Haskell programming has entered the mainstream with support now included in GHC for multiple parallel programming models, along with multicore execution support in the runtime. However, tuning programs for parallelism is still something of a black art. Without much in the way of feedback provided by the runtime system, it is a matter of trial and error combined with experience to achieve good parallel speedups.

This paper describes an early prototype of a parallel profiling system for multicore programming with GHC. The system comprises three parts: fast event tracing in the runtime, a Haskell library for reading the resulting trace files, and a number of tools built on this library for presenting the information to the programmer. We focus on one tool in particular, a graphical timeline browser called ThreadScope.

Windows 7 Sensor and Location - Deep Dive into Location

Yochay Kiriaty — Thu, 20 Aug 2009 18:30:00 GMT

The Windows Sensor and Location platform, new for Windows 7, enables your computer and applications to adapt to their current environment. Previously, we introduced the Windows 7 Location Platform Overview; in this video, we take a deep dive into the Location Platform architecture and APIs. Join Alec Berntson and Yochay Kiriaty as they explains why location gets a special set of APIs and what makes the Location Platform such an amazing platform for developers.

In the Windows 7 Developer Kit you can find Hands On Labs and additional content on Windows 7 Sensor and Location.

You can find additional information about the Windows 7 Sensor and Location Platform in the:

Windows 7 Sensor and Location Platform Developer Center on MSDN
Windows 7 Sensor and Location Platform series of posts
PDC session recording - Windows 7: The Sensor and Location Platform: Building Context-Aware Applications

STM.NET: Who. What. Why.

Charles — Fri, 14 Aug 2009 17:39:00 GMT

Software Transactional Memory is no longer a pipe dream or the stuff of academics. STM.NET, as it's called, is ready for your experimentation.

The goal of STM.NET is to be able to exploit concurrency by using components written by experts and consumed by application programmers who can then compose together these components using STM. Transactional memory provides an easy-to-use mechanism to do this safely. STM.NET is of course not a concurrency silver bullet and this is an experimental rrelease of the .NET Framework that allows C# programmers to try out this technology, specifically a particular implementation of STM.

The STM team really needs your feedback to understand if they're doing the right things to meet your needs. Traditionally, using STM for simple trasactional tasks didn't make sense. The overhead was too high. Is this still the case? What needed to change in the .NET Framework to enable STM.NET? Remember, this is a .NET Framework experiment to enable STM for managed code.

Here, we meet most of the team responsible for STM.NET: Chris Dern‎, Yossi Levanoni‎, Sasha Dadiomov‎, Weirong Zhu‎, Sukhdeep Sodhi‎ and Lingli Zhang.

Tune in, meet the team and get a good sense of what this very small team has accomplished with STM.NET and learn about some of the paths taken to get there. This represents really great engineering. Congratulations to the STM team! Now, Niners, go get the bits!

Enjoy.

Arun Kishan: Inside Windows 7 - Farewell to the Windows Kernel Dispatcher Lock

Charles — Thu, 06 Aug 2009 17:28:00 GMT

You've learned about many of the new features of the latest version of the Windows kernel in the Mark Russinovich Inside Windows 7 conversation here on Channel 9. One of Mark’s favorite kernel innovations is the way the Windows 7 kernel manages scheduling of threads and the underlying synchronization primitives that embody kernel thread management.

Prior to Windows 7 (and therefore Windows Server 2008 R2) the Windows kernel dispatcher employed a single lock, the dispatcher lock, which worked well for a relatively small numbers of processors (like 64). However, now that we find ourselves in the midst of the ManyCore era, well, 64 processors aren’t that many... A new strategy was required to scale Windows to large numbers of processors since a single lock is limited in capability, by design: The masterful David Cutler, one of the world's greatest software engineers, wrote the NT scheduler in a time when the notion of affordable 256-processor machines was more science fiction than probable.

As we learned in the Mark Russinovich video, Windows 7 can now scale to 256 processors thanks to the great engineering of Arun Kishan, a kernel architect you've met on C9 back in the Vista days. In order to promote further scalability of the NT kernel, Arun completely eliminated the dispatcher lock and replaced it with a much finer grained set of synchronization primitives. Gone are the days of contention for a single spinlock. How did Arun pull this off, exactly, you ask? Who is this genius? Well, tune in. Lots of answers await…

Arun's work directly benefits the overall performance of Windows running on many processors and means, simply, Windows can now really scale. Thank you, Arun!

Spinlocks are synchronization primitives that cause a processor to busy-wait until the state of the lock’s memory location changes.

As the name implies, the dispatcher lock is the fundamental lock associated with the kernel dispatcher, or the scheduler.

Kim Hamilton and Wes Dyer: Inside .NET Rx and IObservable/IObserver in the BCL (VS 2010)

Charles — Tue, 04 Aug 2009 17:02:00 GMT

You recently learned about Erik Meijer's latest innovation, Rx, here on Channel 9. Clearly, judging by the views and comments on that post, it piqued your interest and curiosity. Wes Dyer, a rock star developer on Erik's team of rock stars, implemented a great deal of Rx and helped to design it along with Erik.

Visual Studio 2010 will ship with with two new types, IObserver and IObservable. Rock star developer Kim Hamiliton (you've met her on C9) implemented these two types in the BCL and worked closely with Erik and Wes to insure that Rx in the BCL is designed and implemented to meet the strict requirements for new types in .NET's robust general purpose library. As you've learned previously, IObservable is the mathematical dual of IEnumerable. We of course talk about this here, but from the developer perspective. You've already learned about the math and continuation monad behind this with Erik and Brian Beckman.

Here, Kim and Wes dig into the implementation of IObservable and IObserver in the 2010 version of the BCL. How did Erik and team work with the BCL folks? What were the design decisions that led to the final implementation of the two Rx types in the BCL? What do these two new types enable for .NET developers? This is a great example of how innovation comes to market: incubation teams come up with a brilliant idea, refine it by working with multiple teams and some researchers in MSR, pass it along to a product group, they go back and forth on implementation details and design requirements and finally the new stuff is added to the shipping code base. Great stuff!!

Make sure to watch this all the way through. You never know what kind of magic can happen if you know how to summon a wizard.

Enjoy!

Inside the Active Template Library (ATL) Security Update

Charles — Tue, 28 Jul 2009 17:02:00 GMT

Today, Microsoft announced the details of an out-of-band security update that impacts ATL components and controls (like ActiveX controls, for example) -> Developers who have built controls using vulnerable versions of ATL should take immediate action to review and identify any vulnerabilities, modify and recompile their affected controls and components using the updated versions of ATL and finally distribute a non-vulnerable version of the controls and components to their customers.

Here, Damien Watkins from the VC++ team and Damian Hasse and Jonathan Ness from MSRC Engineering review the steps to identify and address vulnerable controls and components. Of course, being a Channel 9 interview, we dig into various aspects of the problem without veering away from the goal here: helping you understand the exact issues with this vulnerability. If you own a component or control that uses ATL, then you will know what you need to do to prevent a possible attack.

Please visit the URLs below as soon as possible for detailed information on this vulnerability.

Resources discussed in this video are available on MSDN: Active Template Library Security Update and Developers

Detailed technical information on this security release for ATL developers: http://blogs.technet.com/srd/archive/2009/07/28/overview-of-the-out-of-band-release.aspx

Additional information on this security release is available on the Security Research & Defense blog

Overview with background + table of links: http://blogs.technet.com/srd/archive/2009/07/28/overview-of-the-out-of-band-release.aspx

IE mitigation explanation: http://blogs.technet.com/srd/archive/2009/07/28/internet-explorer-mitigations-for-atl-data-stream-vulnerabilities.aspx

Deep dive for developers: http://blogs.technet.com/srd/archive/2009/07/28/atl-vulnerability-developer-deep-dive.aspx

How msvidctl.dll is related: http://blogs.technet.com/srd/archive/2009/07/28/msvidctl-ms09-032-and-the-atl-vulnerability.aspx

Michael Howard's perspective on this issue: http://blogs.msdn.com/sdl/archive/2009/07/28/atl-ms09-035-and-the-sdl.aspx

Jan Welker über dotnet-kicks.de

Dariusz Parys — Mon, 27 Jul 2009 15:43:00 GMT

Auf dem .NET Open Space Süd hatte ich die Gelegenheit mit Jan Welker über das Projekt dotnet-kicks.de zu sprechen. Jan erzählt was letztendlich mit dieser Seite gemacht werden kann und wie es dazu kam das er zusammen mit Gordon und Klaus diese Seite aufgebaut hat.

Viel Spaß beim reinschauen,
Dariusz

Stefan Lieser über Clean Code Developer

Dariusz Parys — Mon, 27 Jul 2009 15:43:00 GMT

Auf dem .NET Open Space Süd hatte ich die Gelegenheit mit Stefan Lieser über die Initiative Clean Code Developer zu reden. Auch die Frage auf die farbigen Armbänder wird in diesem Video geklärt.

Viel Spaß beim reinschauen,
Dariusz

Expert to Expert: Erik Meijer and Michael Isard - Inside Dryad

Charles — Tue, 21 Jul 2009 15:55:00 GMT

Microsoft Research recently announced the availability, under Academic Licensing, of Dryad, an infrastructure which allows a programmer to use the resources of a computer cluster or a data center for running data-parallel programs.

A Dryad programmer can use thousands of machines, each of them with multiple processors or cores, without knowing anything about concurrent programming.

That's a pretty heady statement. What does Dryad do, exactly, to enable this level of abstraction, shielding programmers from the incredibly complex world of distributed parallel computing? Does the level of abstraction impact the degree to which sophisticated programmers can interact with and control some of the low level mechanisms of the Dryad runtime? What is it about LINQ that made it the no-brainer managed programming abstraction for Dryad?

Simply, how does Dryad work? This is the core question that Erik and I had after our conversation with Roger Barga (part one of this E2E mini-series on Dryad and DryadLINQ - perhaps we should focus just on DryadLINQ next time, but for now, all the information in this conversation is certain to keep you very busy and answer many questions you may have after learning about Dryad in part one...).

Lots of whiteboarding here. Put on your thinking caps!

Enjoy.

Expert to Expert: Erik Meijer and Roger Barga - Introduction to Dryad and DryadLINQ

Charles — Thu, 16 Jul 2009 16:43:00 GMT

Microsoft Research recently announced the availability, under Academic Licensing, of Dryad, an infrastructure which allows a programmer to use the resources of a computer cluster or a data center for running data-parallel programs. A Dryad programmer can use thousands of machines, each of them with multiple processors or cores, without knowing anything about concurrent programming.

DryadLINQ is the managed high level programming abstraction used to compose Dryad vertex topology graphs that the Dryad infrastructure uses to partition parallel computations. Here, Erik Meijer and Dryad team member Roger Barga discuss Drayad and DryadLINQ at a high level so that most of us can understand the implications, history and future of Dryad. This is an introductory piece. Erik and I will dive deep into Dryad with one of the scientists behind it in the second part of this Expert to Expert mini series on Dryad. UPDATE: The Going Deep episode on Dryad is now live.

Enjoy! This is incredible and important technology for simplifying the inherent complexity of distributed computation in the cloud. In essence, DryadLINQ enables a sequential programming experience over what will execute across potentially thousands of machines (depending upon the computational complexity of the program) concurrently. Much to learn here. Channel 9 will help teach.

Editorial note: When we discuss native code and the implementation of Dryad, the focus is on DryadLINQ not the Dryad infrastructure and low level vertex APIs, which are written in C++. Just to be clear...

Useful links:

Connect site: http://connect.microsoft.com/site/sitehome.aspx?SiteID=891

ER Website on Academic Use: http://research.microsoft.com/en-us/collaboration/tools/dryad.aspx

MSR Info: http://research.microsoft.com/en-us/projects/dryadlinq/

Parallel Computing TechTalk (nur der VS2010 Teil)

Dariusz Parys — Thu, 16 Jul 2009 05:13:00 GMT

Dies ist die Aufzeichnung der Parallel Computing TechTalk Tour die zusammen mit Intel(r) durchgeführt wurde. Die komplette Aufzeichnung des Abends findet sich hier.

Diese Aufzeichnung stellt nur den Teil rund um Visual Studio 2010 vor.

Viel Spaß beim reinschauen,
Dariusz