Entries tagged with erik meijer - Channel 9

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 8 of 13

Charles — Thu, 19 Nov 2009 18:55:00 GMT

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 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.

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 7 of 13

Charles — Thu, 12 Nov 2009 16:42:00 GMT

We've kicked off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

We will release a new chapter in this series every Thursday.

In Chapter 7, Dr. Meijer teaches us about Higher-Order Functions. A function is called higher-order if it takes a function as an argument and returns a function as a result:

twice :: (a -> a) -> a -> a
twice f x = f (f x)

The function twice above is higher order because it takes a function (f x) as it first argument and returns a function (f(fx))

Dr. Meijer will elaborate on why higher-order functions are important and there are some really interesting side-effects of higher-order functions such as defining DSLs as collections of higher-order functions and using algebraic properties of higher-order functions to reason about programs.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 6 of 13

Charles — Thu, 05 Nov 2009 15:53:00 GMT

Some functions, such as factorial, are simpler to define in terms of other functions. As we shall see, however, many functions can naturally be defined in terms of themselves.

Properties of functions defined using recursion can be proved using the simple but powerful mathematical technique of induction.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

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!).

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 5 of 13

Charles — Thu, 29 Oct 2009 17:31:00 GMT

We've kicked off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

We will release a new chapter in this series every Thursday.

In Chapter 5, Dr. Meijer introduces and digs into List Comprehensions. In mathematics, comprehension notation is used to construct new sets from old sets. In Haskell, you can create new lists from old lists using a similar comprehension syntax:

[x^2 | x <- [1..5]]

The above notation represents the list [1,4,9,16,25] of all numbers x^2 such that x is an element of the list [1..5]. The <- [1..5] syntax is known as a generator and list comprehensions can have mulitple generators that can have explicit dependencies on other generators. You will also learn about guards, which restrict values created by earlier generators.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3
Chapter 4

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

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).

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 4 of 13

Charles — Thu, 22 Oct 2009 18:34:00 GMT

We've kicked off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

We will release a new chapter in this series every Thursday.

In Chapter 4, Dr. Meijer teaches us about the art and practice of defining functions. Functions can be defined using conditional expressions and in Haskell conditional expressions must always have an else clause. Functions can also be defined using guarded equations and pattern matching. You will learn about list patterns and integer patterns. Today is also the day that you will learn about lambda expressions and sections.

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2
Chapter 3

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 3 of 13

Charles — Thu, 15 Oct 2009 15:46:00 GMT

We've kicked off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

We will release a new chapter in this series every Thursday.

In Chapter 3, Dr. Meijer explores types and classes in Haskell. A type is a collection of related values and in Haskell every well-formed expression has a type. Using type inference, these types are automatically calculated at run time. If expression e returns a type t, then e is of type t, e :: t. A function is a mapping of one type to another type and you will learn about new types of functions in this lecture, specifically curried functions: functions that return functions as a result (and functions are values, remember) and polymorphic functions (function with a type that contains one or more type variables).

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1
Chapter 2

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 2 of 13

Charles — Thu, 08 Oct 2009 15:33:00 GMT

We've kicked off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

We will release a new chapter in this series every Thursday.

In Chapter 2, Dr. Meijer introduces Haskell syntax and notation (via a Haskell implementation called Hugs, to be precise, which is based on Haskell 98) and we learn about the Haskell syntax that represents the fundamental construct of functional programming: functions. It's not like you're used to in mathematics like f(x). Instead, in Haskell, a function is denoted without parentheses: f x. So, given the almost OCD requirement by Haskell language designers to eliminate any unnecessary clutter in the language, parentheses are replaced by space. Also, in mathematics, you're accustomed to multiplication expressed either as xy or x y. In Haskell, since space denotes a function, multiplication is denoted with a *, like x*y...

You should watch these in sequence (or skip around depending on your curent level of knowledge in this domain):

Chapter 1

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback:

9780521871723 and Paperback: 9780521692694. The catalog pages are:

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723 and the paperback is:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 1 of 13

Charles — Thu, 01 Oct 2009 15:50:00 GMT

Welcome to a new technical series on Channel 9 folded into a different kind of 9 format: C9 Lectures. These are what you think they are, lectures. They are not conversational in nature (like most of what you're used to on 9), but rather these pieces are entirely focused on education, coming to you in the form of a series of high quality technical lectures (1 or more per topic) on a single topic.

We kick off C9 Lectures with a journey into the world of Functional Programming with functional language purist and high priest of the lambda calculus, Dr. Erik Meijer (you can thank Erik for many of the functional constructs that have shown up in languages like C# and VB.NET. When you use LINQ, thank Erik in addition to Anders).

Lecture Context:

Over the past two years, you've learned a fair amount about the functional programming paradigm's foray into general purpose imperative progamming languages (LINQ, Lambda's, etc in C# and VB.NET). And, of course, the newest language to join the Visual Studio family of languages, F#, is a functional language. You've heard us say how important functional language constructs are to the our current languages' capabilities to evolve in the right direction to meet the needs of the many-core future (the need for reliable and comprehensible concurrency, parallelism, etc) and, most importantly, to help vault computer programming into an age of compositionality (remember our talks on 9 regarding composability and evolution of software engineering as an engineering discipline?). Well, we decided to take a step back and teach you the fundamentals of functional programming at a level equivalent to any university. We even have a text book and professor who will expand our minds.

Dr. Erik Meijer will teach us Functional Programming Fundamentals using Haskell as the language for understanding the basic functional principles (in fact, the specific language isn't all that important, but Haskell is a pure functional language so it is entirely appropriate for learning the essential ingredients of functional programming. It is also a relatively small language and should be easy for you to get up to speed with Haskell once you understand the Why, What and How that underlies all functional languages...).

Now, we do have a textbook and you should go buy it: The great Graham Hutton's Programming in Haskell. We worked with the publisher, Cambridge University Press, to get all Niners a 20% discount on the book. Now, you don't need the book to learn a great deal from this lecture series since Graham's website has all the slides and samples from the book as well as answers to the exercises. That said, it's highly recommended reading and you should consider it.

The promotion code is 09HASK and it is vaild on both the Hardback and Paperback.

Hardback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521871723

Paperback:

http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=9780521692694

Note: This special offer is valid until December 31, 2009

In Chapter 1, Dr. Meijer takes us through the fundamental fundamentals of functional programming: The philosophy and history of functional programming. As you can imagine, these lectures will go deeper and deeper as the chapters progress, but you need to understand the philosophical and historical contexts. This will provide a nice layer of fresh conceptual soil in which to plant the seeds of understanding the technical details of functional programming, of functional reasoning.

Welcome to C9 Lectures. Enjoy and learn, learn, learn.

ALWAYS ask questions right here. Erik will answer them. Remember, he is professor Erik Meijer in this context and professors answer the questions of their students. Thank you, Erik, for doing this!

Welcome to C9 Lectures!

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 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/

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.

Philip Wadler and Erik Meijer: On Programming Language Theory and Practice

Charles — Mon, 04 May 2009 17:02:00 GMT

Lang.NET Symposium 2009 was held on Microsoft's campus (make sure you watch the talks, which are available for your viewing pleasure). We were of course there and conducted several interviews with some of programming language design's brightest thinkers.

Here, Erik Meijer and Philip Wadler discuss the theory and practice of programming language design with C# program manager Mads Torgersen.

Philip is widely known for his significant contributions to functional programming (including Haskell and a classic book - Introduction to Functional Programming(Prentice Hall publisher) that is one of the best introductions to functional programming you can find) and programming language theory. You've learned about Mondas on Channel 9. Well, Philip is the guy that is in part responsible for their wide adoption in FP.

Erik, as you know by now, is co-creator of LINQ, functional programming master, creator of the now unnamed "Volta" technologies, and much more.

This is a great conversation on how theory winds its way into practice and how principles take time to embed themselves into modern language design (most modern languages are built on the ideas formed many years ago, as theoretical principles). Phillip and Erik also touch on langauge history and futures. Tune in.

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!