Entries tagged with expert to expert - Channel 9

E2E: Erik Meijer and Dave Campbell: Data, Databases and the Cloud

Charles — Sat, 14 Nov 2009 00:03:00 GMT

Dave Campbell is a Technical Fellow at Microsoft and long time database architect. Today, Dave works on the hardest problems facing SQL's foray into the new world of cloud computing. His latest project in this space takes the form of SQL Azure. What is SQL Azure? What's the different with the cloud and what we already experience with SQL server running in a clustered environment and reachable via the Internet? How does this focus on cloud computing and impact the evolution of database design? What's going here? What's next? Erik Meijer, de facto E2E host and language designer, interviews Dave to ge answers to some of these questions. Erik works for Dave, by the way, and as you can see that doesn't stop Erik from asking more than softball questions.

Dave will be presenting at PDC09 in the Technical Leaders track. His talk will focus on ambient data and what this means for the evolution of ways to understand and shape the data this all around us using software. You should attend his session and come with questions if you are going to be at PDC. If you're not going to be there, then make sure to ask Dave questions when he appears on Channel 9 Live!

Enjoy!

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.

E2E: Erik Meijer and Burton Smith - Concurrency, Parallelism and Programming

Charles — Tue, 03 Nov 2009 16:19:00 GMT

The great Burton Smith, Microsoft Technical Fellow and an international leader in high-performance computer architecture and programming languages for parallel computing joins functional programming purist and language design guru Erik Meijer to discuss several major themes of parallel computing and distributed programming. As always, you will get a lesson in history, present trends and future possibilities. This is simply an awesome and deeply wonderful conversation. Burton is a treasure.

Erik shows up for the conversation only after Burton begins to talk about a potential definition for functional programming. Right on queue, Erik arrives!

Burton will be presenting his thinking on parallel and concurrent programming at PDC09. He will also be a panelist on the Future of Programming panel (and Erik will be the panel moderator - you won't want to miss the panel if you are attending PDC!).

E2E: Erik Meijer and Don Box - Perspectives on SOAP, Programming Data and M

Charles — Wed, 28 Oct 2009 16:52:00 GMT

Don Box is a Distinguished Engineer at Microsoft and has a rich history in the general purpose programming world. You remember SOAP, right? Don was one of the Gang of Four who designed SOAP. Don was also instrumental in the design and implementation of WCF. Don is currently building a new model-based data programming platform, code-named Oslo, along with a new language for describing data, M.

Erik Meijer, programming language and library designer, chats with Don about the history of SOAP, model-based programming, data and M. Don will be at PDC09 and in addition to giving his usual stellar performance as a session speaker, he will be part of the Future of Programming panel (a view into Microsoft's perspective on trends and possibilities for general purpose programming in the age of many-core and cloud computing).

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!

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.

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/

Expert to Expert: Brian Beckman and Erik Meijer - Inside the .NET Reactive Framework (Rx)

Charles — Thu, 09 Jul 2009 18:36:00 GMT

Erik Meijer and team (developer Wes Dyer, in particular) have created a profound and beautiful .NET library that will take managed event based programming to new levels. Of course, many of you wish that you could write LINQ expressions over events. Well, now you can thanks to Erik's and Wes Dyer's latest creation, Rx - .NET Reactive Framework. Erik, being a fundamentalist functional theoritician, can't create new programming abstractions without employing some form of monadic magic.

Enter astrophysicist and monadic composition wizard Brian Beckman. The last time Brian was on C9 he taught us about the State Monad. At the end of that discussion he mentioned he wanted to teach us about the Continuation Monad next. So, who better to conduct this episode of Expert to Expert than Dr. Beckman? Yep. You guessed it! Rx employs the Continuation Monad in its composition. Erik is in the hot seat this time and it's always a real pleasure to converse with Erik and Brian in the same room at the same whiteboard.

Now, what is Rx?

The .NET Reactive Framework (Rx) is the mathematical dual of LINQ to Objects. It consists of a pair of interfaces IObserver/IObservable that represent push-based, or observable, collections, plus a library of extension methods that implement the LINQ Standard Query Operators and other useful stream transformation functions.

interface IObservable<out T>
{
    IDisposable Subscribe(IObserver o);
}

interface IObserver<in T>
{
    void OnCompleted();
    void OnNext(T v);
    void OnError(Exception e);
}

Observable collections capture the essence of the well-known subject/observer design pattern, and are tremendously useful for dealing with event-based and asynchronous programming, i.e. AJAX-style applications. For example, here is the prototypical Dictionary Suggest written using LINQ query comprehensions over observable collections:

IObservable<Html> q = from fragment in textBox

from definitions in Dictionary.Lookup(fragment, 10).Until(textBox)

select definitions.FormatAsHtml();

q.Subscribe(suggestions => { div.InnerHtml = suggestions; })

Please subscribe to this Channel 9 interview to be notified when we have clearance to distribute Rx over the counter (lame puns intended :-).

Tune in. This should prove to be an instant classic besides being a very important episode of E2E. Rx is deep, man. Deep.

Enjoy!

Expert to Expert: Harry Shum - General Purpose Search, Decision Engines and Bing

Charles — Wed, 01 Jul 2009 03:44:00 GMT

Harry Shum is the VP of Engineering for Bing, Microsoft's latest search engine offering (well, it's more than a search engine - it's a so-called Decision Engine, but what does that mean, precisely?). Harry has a long history in the world of complex algorithm design and implementation. Before joining the Bing team (at Bill Gates' request), Harry was a reseacher in MSR specializing in computer vision, which is an algorithm instensive discipline rife with machine learning principles, statistics and in some sense artificial "intelligence" in terms of autonomous pattern recognition capability. At any rate, Harry is a developer and scientist through and through. We're very fortunate to have him running our search engineering efforts. General purpose search is an incredibly fascinating area with a great deal of potential, challenges and opportunities.

Erik Meijer, programming language designer, knight of the lamda calculus and Expert to Expert host, sits down with Harry to learn, at a high level (though deep in context), how Bing works, what, exactly, a decision engine is, what really happens when you Bing something and various topics related to the computation behind both general purpose search and accurately interpreting user intention. Of course, being an E2E, we take the conversation in many directions and Harry was a real sport. Thank you, Harry!

If you want to know the past, present and a little bit of the future of Bing technology, well, tune in and meet Harry Shum; a computer scientist, software developer and vice president.

Enjoy!

Expert to Expert: Web Programming, JavaScript with Types and Flapjax

Charles — Tue, 23 Jun 2009 18:21:00 GMT

Flapjax is a new programming language designed around the demands of modern, client-based Web applications. Its principal features include:

Event-driven, reactive evaluation
An event-stream abstraction for communicating with web services
Interfaces to external web services

Flapjax is easy to learn: it is just a JavaScript framework. Furthermore, because Flapjax is built entirely atop JavaScript, it runs on traditional Web browsers without the need for plug-ins or other downloads. It integrates seamlessly with existing JavaScript code and other frameworks. [Source = http://www.flapjax-lang.org/]

Shriram Krishnamurthi is one of the authors of Flapjax and was in town recently giving a series of lectures to fellow programming language researchers in MSR. Shriram is a professor of computer science at Brown University. Expert to Expert host and programming language designer Erik Meijer is also doing some interesting things with event driven reactivity (you'll learn all about this soon...) so the two language guys just had to chat and we had to film it. Tune in to see what happened in Erik's office over the course of an hour or so. A fair amount of time is spent discussing the reasoning behind and benefits of adding types to a language like JavaScript. It's an interesting idea, but what does it mean for web developers (who, potentially, adopted JavaScript for its wide open and highly dynamic characteristics in the first place).

As usual, there's no editing here. It's as though you just came along and watched the magic unfold. Much thanks to Shriram for taking the time to chat with us. Flapjax is impressive. Do give it a try, Niners.

Expert to Expert: Gur Kimchi - Inside Bing Maps (aka Virtual Earth)

Charles — Wed, 17 Jun 2009 17:54:00 GMT

Erik Meijer and I paid a visit to Bing Maps infrastructure architect and Partner Development Manager Gur Kimchi for an Expert to Expert conversation about the design and architecture of Bing Maps. It takes some rocket science to process and coerce data into accurate information representative of points of interest on planet Earth. How does Bing Maps work, at the deepest levels, in the cloud? Gur and team have created a very efficient back end system that computes and returns the information you seek when using Bing Maps. Tune in. This is yet another great conversation among experts (not including myself, of course - I need to limit my caffeine intake before E2E's going forward... :)).

Enjoy!

Expert to Expert: Inside Bling - A C#-based library to simplify WPF programming

Charles — Mon, 08 Jun 2009 21:45:00 GMT

Bling is a C#-based library for easily programming images, animations, interactions, and visualizations on Microsoft's WPF/.NET. Bling is oriented towards design technologists, i.e., designers who sometimes program, to aid in the rapid prototyping of rich UI design ideas. Students, artists, researchers, and hobbyists will also find Bling useful as a tool for quickly expressing ideas or visualizations. Bling's APIs and constructs are optimized for the fast programming of throw away code as opposed to the careful programming of production code.

Some features of Bling:

Declarative constraints that maintain dynamic relationships in the UI without the need for complex event handling. For example, button.Width = 100 - slider.Value causes button to shrink as the slider thumb is moved to the right, or grow as it is moved to the left. Constraints have many benefits: they allow rich custom layouts to be expressed with very little code, they are easy animate, and they support UIs with lots of dynamic behavior.

Simplified animation with one line of code. For example, button.Left.Animate.Duration(500).To = label.Right will cause button to move to the right of label in 500 milliseconds.

Pixel shader effects without the need to write HLSL code or boilerplate code! For example, canvas.CustomEffect = (input, uv) => new ColorBl(new Point3DBl(1,1,1) - input[uv].ScRGB, input[uv].ScA); defines and installs a pixel shader on a canvas that inverts the canvas's colors. Pixel shading in Bling takes advantage of your graphics card to create rich, pixel-level effects.

Support for multi-pass bitmap effects such as diffuse lighting.

An experimental UI physics engine for integrating physics into user interfaces! The physics supported by Bling is flexible, controllable, and easy to program.

Support for 2.5D lighting.

A rich library of geometry routines; e.g., finding where two lines intersect, the base of a triangle, the area of triangle, or a point on Bezier curve. These routines are compatible with all of Bling's features; e.g., they can be used in express constraints, pixel shaders, or physical constraints. Bling also provides a rich API for manipulating angles in both degrees and radians.

And many smaller things; e.g., a frame-based background animation manager and slide presentation system.

As a lightweight wrapper around WPF, Bling code is completely compatible with conventional WPF code written in C#, XAML, or other .NET languages.

Sounds very interesting. Well, Erik and I wanted to find out more about Bling (Is it a library or a DSL? Is WPF programming really that hard? How is Bling designed and what makes it a simplified abstraction over a full featured platform technology like WPF?). It just so happened that Bling creator and software developer Sean McDirmid was in town recently (he works at Microsof's Advanced Technology Center located in Beijing, China). Tune in to see how the latest E2E unfolded (you must realize by now that we never really plan anything and E2Es just happen as you see them - it's just part of the game we play). Bling is an interesting idea with potential. Simplifying complexity is an important goal.

Enjoy.

Expert to Expert: Martin Fowler and Chris Sells - Perspectives on Domain Specific Languages

Charles — Mon, 11 May 2009 19:14:00 GMT

Microsoft Olso Program Manager Chris Sells and DSL expert Martin Fowler discuss the history and future of Domain Specific Languages (DSLs). This was filmed at DevCon 2009, which took place on the Microsoft campus in Redmond, WA, USA. For those of you who don't know, Martin Fowler is a legendary software engineer and one of the industry's most accomplished speakers. For the past few years Martin has spent a great deal of time thinking about and implementing DSLs. He's viewed, by his peers and the industry at large, as the de facto DSL guru. You should most definitely watch his talk from this year's DevCon.

Expert to Expert - Erik Meijer and Lars Bak: Inside V8 - A Javascript Virtual Machine

Charles — Wed, 29 Apr 2009 16:29:00 GMT

Lars Bak is a virtual machine master. He and team have created a Javascript VM, V8, that takes Javascript syntax and produces optimized machine code directly. The result is very performant execution of Javascript. How does V8 work, exactly? What are the basic design decisions that have gone into it's construction? Why is it designed the way it is? How fast can Javascript really run, anyway? How challenging is it to take a language like Javascript and produce highly optimized machine code?

Erik Meijer, language designer and fundamentalist functional high priest, discusses these questions and more with Lars. We also talk about the language to machine code translation versus having an intermediate step (like IL) that gets optimized further in runtime context by a JITer.

If you want to know the thinking behind the thinking of Javascript compilation, the current state of the art and future directions, then this is for you. Big thanks to Lars Bak for spending time with Channel 9!

Enjoy!

Expert to Expert: Amitabh Srivastava - Windows Azure and Cloud Computing

Charles — Tue, 14 Apr 2009 15:51:00 GMT

You first learned about Windows Azure and the Azure Services Platform at PDC08. Remember that? Yeah. It's been a while since we first unveiled our cloud computing offering. Now that the hysteria has died down, we thought it wise to go learn the details behind and inside Azure. Who better for this next iteration of Expert of Expert than Windows Azure VP Amitabh Srivastava? Exactly.

Amitabh is a computer scientist turned VP. Lucky for us, he chose the Azure project (formerly known as Red Dog) to put his IQ to work. He built a great team including the venerable and mysterious genius David Cutler (what did David build for Azure, anyway? Tune in...). Much brain power followed the trail to Azure clad in red sneakers with distributed visions of cloud computing in their heads. What would they make? How will it evolve?

What is Azure, exactly? Why are we (Microsoft) doing this? What does cloud computing really mean, anyway? Why "Red Dog" for the code name? Is this just hosting? How is Azure different than what, say, Amazon has already been doing for a few years? What's the score here? What's next?

Erik Meijer leads the questioning and Amitabh does a great job explaining things in a readily understandable way. Great stuff!

Enjoy

Expert to Expert: Helen Wang and Alex Moshchuk - Inside Gazelle

Charles — Tue, 07 Apr 2009 17:48:00 GMT

Microsoft Research was in the news not too long ago regarding the innovative, outside-the-box research being done by MSR scientists on display at the annual MSR TechFest event. One of the stars of the show was a new web browser project named Gazelle.

Gazelle is a Microsoft Research prototype web browser constructed as a multi-principal OS (emphasis on research and prototype). From the Gazelle Microsoft Research Technical Report: Gazelle’s Browser Kernel is an operating system that exclusively manages resource protection and sharing across web site principals. This construction exposes intricate design issues that no previous work has identified, such as legacy protection of cross-origin script source, and cross-principal, cross-process display and events protection.

Interesting, Captain. This really piqued our curiosity so Erik Meijer and I decided to find out the inside scoop on Gazelle. Why choose an OS architecture to model a web browser? How does it work, exactly? What does multi-principal mean in the context of execution of web pages? Aren't we talking about isolated processes? What happens when a principal is compromised? Is the browser kernel completely isolated from code executing in a principal context(is it possible to "blue screen" Gazelle)? What are the intrinsic challenges with implementing this design? How performant is a multi-principal, kernel-based web browser (what if you have 40 principal contexts running simultaneously, for example)?

This is a great conversation with Gazelle project lead Helen Wang and Alex Moshchuk, a PhD student intern developer working on the Gazelle project. We cover a lot of ground and Erik and I are unusually curious given the fascinating model Gazelle represents for a truly secure web browser.

Enjoy! This is a birthday present from Channel 9 to you!

Erik Meijer and Matthew Podwysocki - Perspectives on Functional Programming

Charles — Tue, 24 Mar 2009 15:50:00 GMT

Matthew Podwysocki is a senior consultant for Microsoft platform technologies in the D.C. area. He's been programming since he was a child and has a particular interest and passion for functional programming. Functional programming is all the rage these days. General purpose imperative languages (like C# and C++) are adding functional constructs to help improve software developer prodcutivity in an increasingly concurrent general purpose computing environment as notebooks and PCs with multiple processors are now the norm.

Matthew was in Redmond a few weeks ago, so we thought it would be awesome to invite Matthew into the the lair of our resident functional programming extremist (though I must say that Erik is mellowing out with age), high priest of the lamda calculus, category theorist and Expert to Expert host, Erik Meijer. Now, it's a little scary to be asked into Erik's den of functional orthodoxy (aka Erik's office) and be put to the task of explaining functional principals in a way that is widely accessible to developers who have little or no experience with thinking functional, but Matthew was up for the task and spends most of the time at Erik's whiteboard explaining important functional programming concepts (Haskell and F# are the languages used in the examples, but the language isn't that important - the concepts are), sharing some his very interesting history with us, waxing on future directions in programming, engaging us in a really interesting conversation. Great job, Matthew!

Enjoy!

Duration: 1:07:41

Expert to Expert: Erik Meijer and Anders Hejlsberg - The Future of C#

Charles — Tue, 03 Mar 2009 20:16:00 GMT

It's always a pleasure to get a chance to sit down and geek out with Anders Hejlsberg. Anders is a Microsoft Technical Fellow (a Technical Fellow is the highest ranking technical position at Microsoft) and programming language design master. He's the creator of C# and one of the founders of .NET. Anders is an expert language design craftsman. C# is one of the most popular languages Microsoft has created and certainly the most widely used language by developers who target the .NET platform.

Erik Meijer, Expert to Expert host, programming language designer and occasionally-radical category theoritician, has spent many years working with Anders and the C# team. As you may know, Erik has been a key contributor to the addition of functional constructs to C#.

Here, Erik and Anders wax on topics ranging from the design of C# 4.0's dynamic keyword (what's the thinking behind the thinking) to the potential near and far future of the C# language (and general purpose imperative programming, generally). Anders also spends some time at the whiteboard explaining C# 4.0's support for covariance and contravariance. Of course, we can't forget about concurrency and parallelism, so we don't.

As you might expect, the conversation takes some interesting jaunts into various programming language design rabbit holes. For example, Anders discusses the notion of creating a new language to support new problem domains versus extending current languages to meet the needs of developers who need to express solutions to complex problems (so, how do you make a language like C# more dynamic in the sense that it can readily help developers solve problems that the language was not initially designed to solve?). We talk about the work being done on a service-oriented C# compiler (compiler as a service), C# as an ESDL container (or as an EDSL itself to be hosted in other environments...) and much more. This is a fantastic conversation with some of Microsoft's true visionaries. Enjoy.

Expert to Expert: Inside Concurrent Basic (CB)

Charles — Wed, 25 Feb 2009 23:09:00 GMT

"Concurrent Basic extends Visual Basic with stylish asynchronous concurrency constructs derived from the join calculus. Our design advances earlier MSRC work on Polyphonic C#, Comega and the Joins Library. Unlike its C# based predecessors, CB adopts a simple event-like syntax familiar to VB programmers, allows one to declare generic concurrency abstractions and provides more natural support for inheritance. CB also offers open extensibility based on custom attributes."

Code Sample:

Module Buffer

Public Asynchronous Put(ByVal s As String)

Public Synchronous Take() As String

Private Function CaseTakeAndPut(ByVal s As String) As String When Take, Put

Return s

End Function

End Module

OK. Sounds great. There are new keywords, Asynchronous and Synchronous. Conceptually, these are easy enough to understand. How do they work, exactly? What's the thinking behind the current design? Why was VB.NET chosen as the language to extend? Wouldn't any CLI language suffice? Who thought this up, anyway? What's the thinking behind the thinking?

Enter C9 celebrity host Erik Meijer, who leads yet another great conversation with fellow software experts Claudio Russo (MSR Researcher and co-creator of Concurrent Basic) and Lucian Wischik (software developer and current VB.NET Czar).

Obviously, we've been focusing a lot of attention of Concurrency and Parallelism over the past few years. We talk about the library versus language approach quite a bit. In this case, concurrency constructs have been baked into the language to form a different variant of VB, CB (Concurrent Basic). CB is a research project and therefore a research language. It has no ship vehicle and is not available for trial at this point. Microsoft makes no committment to shipping VB with these concurrency constructs built in. CB is a research language. CB is being shown in action at this year's MSR TechFest. Be sure to check out Laura's coverage of TechFest 2009.

Expert to Expert - Joe Duffy: Perspectives on Concurrent Programming and Parallelism

Charles — Tue, 17 Feb 2009 17:39:00 GMT

Joe Duffy spends a lot of time thinking about the future of concurrent programming and parallelism. In his role as Lead Developer in the Parallel Computing Platform team, Joe is the creator of PLINQ and a key contributor to many of the managed (.NET) concurrency incubations happening in and around his broader team. He's also an author (check out his latest book, Concurrent Programming on Windows)

You've met Joe many times before on C9 and the concurrency topic should be quite familiar to you by now (There's a lot of very innovative thinking going on in the parallel computing platform team (and it's not just about the managed world, as you know)).

We've spent a lot time discussing library-based approaches to enabling parallelism in a readily understanable, predictable, safe and scalable way for .NET programmers. We've also spent time on language level approaches to the problem (new constructs in C# that make it easier to compose in a semi-functional way (lamdas, LINQ, etc) or purely in a hybrid-functional way in F# or with experimental DSLs like Maestro).

Erik Meijer, Expert to Expert host, programming language designer and one of the high priests of the lamda calculus spends a great deal of time thinking about the problem of software's capability to scale effectively (as efficiently, safely, and as composable as possible) in the Many-Core age. So, we add Joe + Erik and we get many excellent, insightful questions and answers. Of course the notion of side-effects plays a big role here and we even debate the merits of Haskell in the real world. This is a great conversation. It goes deep, but not so far into the rabbit hole that you won't be able to find your way back. :)

Enjoy!

Expert to Expert: The Basics of SmallBasic

Charles — Tue, 20 Jan 2009 19:00:00 GMT

SmallBasic is a new programming language aimed at beginners. It was created as a side project of Vijaye Raji, a software developer on the Oslo team. SmallBasic is a very limited language with only a handful of keywords and a small set of concepts that should make builing an application on Windows very simple for beginners. However, don't let it's simplicity fool you into thinking that you can't build very compelling applications with it on Windows...

Here, programming language designer (and de facto Expert to Expert host) Erik Meijer, Oslo architect Chris Anderson, Vijaye Raji and I discuss the details behind, in between and in front of SmallBasic. Why was it created in the first place? Why the VB-like syntax? What's the goal of the language and runtime, anyway, given that there are already beginning languages out there that run on the Microsoft stack? Why is the language designed in the way that it is? Why is it so popular? How will it evolve? You know, typical Channel 9 questions. We go pretty deep here, but we don't touch bottom. It was a lot of fun taking part in this conversation and I am impressed with SmallBasic and the folks behind it.

Tune in. If you want to know the details behind (and in front of) SmallBasic, then this conversation is for you.

Enjoy

Expert to Expert: Meijer and Chrysanthakopoulos - Concurrency, Coordination and the CCR

Charles — Fri, 16 Jan 2009 20:56:00 GMT

In this episode of Expert to Expert, programming language designer Erik Meijer chats with CCR creator George Chrysanthakopoulos. We've spent a good deal of time on Channel 9 addressing the Concurrency Problem and the various approaches Microsoft is taking in an effort to help solve it. George's CCR is a piece of managed technology (.NET) that provides an unusually high degree of concurrency for developers targeting Windows. The Coordination and Concurrency Runtime has been around for about five years. How are people using it today to build scalable concurrent systems? What's the current state of the CCR and what's it's future? Why is the CCR a better approach to scalable distributed concurrent programming than other technologies out there? Is concurrency the real issue? George believes that it's all about coordination(the other C in CCR) and concurrency is really just a side effect of coordinating systems. If you get distributed coordination right, then you have a concurrent system that can scale. Really? Do explain, dear George (oh, and he does and as passionately as you'd expect from him). This is a fantastic conversation. Classic Channel 9.

Enjoy!

Expert to Expert: Erik Meijer and Jeffrey Snover - Inside PowerShell

Charles — Wed, 03 Dec 2008 21:19:00 GMT

Welcome to another edition of Expert to Expert. Once again the venerable language master Erik Meijer leads the conversation. This time, we're lucky enough to have PowerShell creator and Partner Architect Jeffrey Snover. Jeffrey is really passionate about PowerShell and has worked hard to see that his .NET shell scripting technology ships in Windows 7 (it is on by default in Windows 7 and is used by administration components of the new OS). Erik is a big fan of PowerShell (especially since the code name of PowerShell was "Monad":)) so we figured it would be useful to have Erik dig into the nitty gritty of PowerShell with Jeffrey and determine exactly what PowerShell is, how it's designed (and why), how it's used primarily (and secondarily) and finally how it will evolve. PowerShell is much more than a Windows-based shell scripting language and engine. But what, exactly, does this statement mean? Tune in. This is yet another great conversation between two stalwarts of the programming industry. Enjoy!