Entries tagged with compilers - Channel 9

Trishul Chilimbi - Green - Energy Efficient Software

Peli de Halleux — Tue, 15 Sep 2009 20:17:00 GMT

Trishul Chilimbi, a researcher from RiSE talks about Green. Green enables programmers to approximate expensive functions and loops while providing statistical quality of service guarantees. By giving away a couple percents of QoS, some applications may decrease their energy consumption by as much as 20%. Watch this video to learn all the details about Green...

Green Technical Report
Green story on Microsoft Research

The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA.

Peter Villadsen and Gustavo Plancarte: X++ to MSIL

Charles — Tue, 01 Sep 2009 16:27:00 GMT

Dynamics Program Manager Peter Villadsen and Software Developer Gustavo Plancarte teach us about a new tool they've developed that translates X++ byte code into MSIL. We learn a lot of history along the way and gain insights into the process of taking X++ into the .NET age.

Microsoft Dynamics features a proprietary language called X++ (basically a superset of Java, with some strong data primitives added) and a complete stack (compiler, interpreter and debugger) that goes with it. The new feature Peter and team have developed is a tool to generate managed code from the X++ intermediate language produced by the X++ compiler. This will have profound impact on the performance of the business applications written in X++, and it very clearly points to where they'll be going in the next few releases of Dynamics Ax.

Tune in.

LINQ Language Deep Dive with Visual Studio 2008

Beth Massi — Wed, 22 Jul 2009 05:13:00 GMT

Ever wonder what really happens when you write a simple LINQ query? A lot of new language features went into the compilers in Visual Studio 2008 to make LINQ work. In this interview I sit down with Jonathan Aneja, a Program Manager on the Visual Basic Compiler team, who dives deep into these features like Type Inference, Anonymous Types, Lambda Expressions, Expressions Trees, and more. He explains what's actually happening behind the scenes and all the work the compiler is doing for you when you write a LINQ query. My head almost explodes at the end but I learned a lot of important concepts. ;-)

Check out Jonathan on the VB Team Blog.

Enjoy,
-Beth Massi, Visual Studio Community

Louis Lafreniere: Next Generation Buffer Overrun Protection with /GS++

Charles — Tue, 02 Jun 2009 16:34:00 GMT

From the C++ Team Blog: A lot of code written in C and C++ has vulnerabilities that leave their users open to buffer overrun attacks. There are two major reasons for this. One reason is that the languages provide unfettered access to the vulnerable memory; the other reason is that developers make mistakes. The simple fact is that even following the best practices and performing quality checks, by the end of the day, no developers can get 100 percent of their code right all the time. Thus, additional built-in layers of defense to help track down vulnerable areas of code are in order. The Visual C++ compiler’s GS switch, which is on by default, is one of the built-in defenses designed to mitigate the buffer overrun attacks.

With VC 10, the next iteration of VC that ships with Visual Studio 2010, Louis Lafreniere and team have delivered the next iteration of /GS, /GS++. /GS proved to be invaluable for C++ developers wanting compile time checking for buffer overrun vulnerabilities in their code. specifically targetting string buffers. Well, turns out that certain structs proved to be a suitable exploit and /GS did not check data structures like structs. Louis et al, with /GS++, now check for certain typed of struct vulnerability (stack allocated).

Here, Principal Developer Louis Lafreniere takes us through the history and future of /GS, in a deep way, of course. Most of the time is spent at the whiteboard mapping out exactly how /GS works and what to expect from /GS++.

Enjoy!

Luca Bolognese: C# and VB.NET Co-Evolution - The Twain Shall Meet

Charles — Wed, 13 May 2009 15:45:00 GMT

For most of their lifetimes, C# and VB.NET have evolved at their own pace and in their own ways (C# added iterators, VB.NET didn't. VB.NET added XML Literals, C# didn't. etc, etc...). Today, Luca Bolognese and team have embarked on a new approach to how .NET's premiere languages will evolve going forward: Co-Evolution. Essentially, new language/compiler features will be developed for each language concurrenly. No longer will C# get new language construct X while VB.NET adds Y. They will both get X (and they will both get Y). Anders Hejlsberg, the father of C#, now oversees both languages and will make sure that language innovations are developed for C# and VB.NET at the same time.

I visited Luca recently to get a sense of the rationale behind this new co-evolutionary approach to two very different languages. Why is co-evolution important? Why not just have the languages, which target different demographics (do they?), evolve in ways that match the needs their users? What's the story here? What's next?

Michal Moskal - VCC, The Verifying C Compiler

Peli de Halleux — Fri, 30 Jan 2009 10:25:00 GMT

Michal Moskal gives us a short introduction at the Verifying C Compiler (VCC) project. VCC is a tool that proves correctness of annotated concurrent C programs or finds problems in them. VCC extends C with design by contract features, like pre- and postcondition as well as type invariants. The current primary goal of the VCC project is to to verify Microsoft Hyper-V. Hyper-V is a hypervisor -- a thin layer of software that sits just above the hardware and beneath one or more operating systems. The Hypervisor verification project is a cooperation between European Microsoft Innovation Center in Aachen, Germany the RiSE group at Microsoft Research in Redmond and the Saarland University in Saarbrücken, Germany.

VCC slide deck, get the high-level picture and more details,
VCC home page, all you want to know.
Unfortunately, there is currently no download available of VCC.

The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA.

Russell Hadley: The Route to C++ Code Optimization

Charles — Tue, 20 May 2008 18:43:14 GMT

It's nice to write clean code (code that looks good, is organized, is easy for others to understand by reading it, etc). As developers we get to use great tools to implement algorithms in our favorite languages. The act of composing a program is much like that of writing a story or, in some cases, a poem :) But the underlying hardware isn't much interested in intelligent class hierachies and easy-to-understand lines of programming language syntax. Processors do not speak C++ or Java or C# or VB, etc.

The focus of this interview is mapping the (long and complicated)path to executable machine code that the machine natively understands and acts upon, bringing your code to life. How does this work, exactly?

Russell Hadley is a senior developer on the C++ team here at Microsoft and he spends his days (and nights, ocassionally) writing code that takes the front-end compilation linear (flattened) blob and turns it into highly optimized machine code patterns that the processor can execute in a highly efficient manner.

This is a deep interview with lots of whiteboarding, but it is shallow enough so you won't drown if you can't swim very well. Enjoy. This is another great conversation with one of the C++ experts who live in Building 41.

LOW RES FILE
MP4 FILE

Andy Ayers: Understanding the Phoenix Compiler Framework

Charles — Wed, 09 Apr 2008 19:19:36 GMT

The compiler gurus over in CTP of the Phoenix Compiler Framework. It's been a while since we've learned about Phoenix here on Channel 9 so we thought it necessary to find out what's going on with the soon-to-be de facto compiler technology for all of Microsoft's products.

Andy Ayers is an Architect on the Phoenix team. He sits down with us to dig into the details of Phoenix and address it's current state, history and future (no whiteboarding here, but this is still quite deep. There is a cool demo at the end of the interview.) . It's very interesting to note that the Phoenix team has tested the scalability and power of their pluggable (extensible) compiler framework on the likes of Windows. Turns out Phoenix handles such a large task (compiling Windows) very well. This new compiler technology has been designed with many-core in mind. This means Phoenix is our most parallelized compiler which adds up to shorter compilation time. As usual, the C++ team is ahead of the curve when it comes to preparing for the concurrent future.

Tune in and learn all about the future of Microsoft's compiler technology from one of the minds behind it all. The future is very bright indeed!

Enjoy!

Low res version here.

Charles Nutter and Wayne Kelly: Making Ruby Run on Static Virtual Machines - JRuby(JVM) and Ruby.NET

Charles — Mon, 11 Feb 2008 20:28:13 GMT

At Lang.NET 2008, I caught up with two dynamic languages afficianados who have been working on a similar (and really hard)problem over the years: getting Ruby (a dynamic language) to run on a static virtual machine (JVM and CLR, respectived).

Charles Nutter is a lead developer on the JRuby project which aims to run Ruby "natively' on the JVM. Wayne Kelly is the lead developer on the now defunct Ruby.NET project (it's been merged into the IronRuby project so Wayne and team's great work has not gone with the wind...) which aimed to get Ruby to run on the CLR.

Both Charles and Wayne are challanged by the same technical hurdles: Running dynamic code in a statically-typed environment with no support for continuations. This is really challenging and is the primary reason that Microsoft created the DLR...

Here, we chat about that they're working on and what problems they face.

Another interesting discussion with brilliant people at Lang.NET 2008.

Enjoy.

Low res download file.

Erik Meijer, Gilad Bracha, Mads Torgersen: Perspectives on Programming Language Design and Evolution

Charles — Tue, 05 Feb 2008 19:52:00 GMT

I attended Lang.NET 2008 and, as expected, learned a great deal from some of the industry's finest language and compiler minds. One of the most interesting talks was Gilad Bracha's session on his new programming language, Newspeak. Newspeak is really compelling from a language design perspective because of its pluggable type system (everything in Newspeak is virtual). His talk was really deep and targeted at his fellow language designers, but it's all starting to make sense to me now (takes a while to sink into my thick skull).

Erik Meijer, our resident programming language guru and a deacon in the Church of the Lamda Calculus (:)), was of course in attendance and presented on the current state of Volta (an excellent managed tier-splitting technology that you should definitely play with).

Mads Torgersen, Danish computer scientist and member of the C# design team, was also in attendance. It's always fun to chat with Mads. He's got a very well balanced and insightful perspective on pragmatic programming language design. We're lucky to have him working with Anders et al on the evolution of C#.

I thought it would be a great idea to get these three characters together in one place to talk about what they know best: programming languages. We have a great discussion on type systems, programming language history, DLR and language futures.

If you are into programming language design, then this is for you. There is no white boarding, but the conversation is deep given the topics covered... It's also a really fun interview with exceptional personalities. We laugh a lot, which is always a good thing. So, step outside of the box, settle into a comfy chair (this is a long one - unedited as usual) and get some new perspectives on programming language design and evolution from some of the top minds in the industry.

Enjoy!

Lo-Res version for the bandwidth challanged.

Ale Contenti and Louis Lafreniere: Understanding Exceptions and When/How to Handle Them

Charles — Fri, 21 Sep 2007 00:47:00 GMT

Sometimes, things go wrong when code executes. You can't predict when this will happen or even why, but you can write code to handle exceptional problems. If you're lucky, the problem will carry with it a bunch of useful information that you can use, at runtime, to handle the specific error. These exceptional information structures are called structured exceptions; blobs of bad news carrying useful and specific information that you can use to find your way out of the exceptional rabbit hole. Of course, with useful data packaged up in an exception you can more easily debug to find root causes, which is much harder to do with, say, error codes...

What is a structured exception, exactly? How should you handle exceptions that you don't assume will arise during the execution of your code? What are the correct patterns of exception handling that you can safely rely on? What does the C++ compiler have to do with exception code patterns?

Come along for ride into the deep and murky world of exceptions with some folks that truly understand them at the most fundamental levels.

Ale Contenti is a senior development lead in the C++ base class libraries team. Louis Lafreniere is a principal software developer in the C++ compiler group. Here, Ale and Louis teach us about exceptions and handling them (and when not to handle them). I love talking to the VC++ People. They live on the metal and really understand the fascinating intracacies of our platform.

Enjoy this latest Going Deep episode.

Luke Hoban: Orcas - Compiling LINQ, C# Futures, Intellisense

Charles — Fri, 18 May 2007 01:25:39 GMT

Meet Luke Hoban, Program Manager on the C# Compiler team. Here, we talk about how LINQ works, from a compiler point of view. As you know by now, LINQ is a construct that is built of new language level innovations which of course must have compiler support... As you might imagine, given the nature of LINQ's requisite language level components, we talk about functional programming and it's new role in our good old imperative world. In Orcas, you shouldn't talk about LINQ without showing it in action inside of Visual Studio.

Enjoy.

For the detail-oriented folks out there: I shot this interview a few months ago, so you'll hear references to the Feb/March CTP. Have no fear, Niners, the content in this interview is as pertinent now as it was then (even more so with the release of Orcas beta 1).

John Gough and Joel Pobar: Compilers, Compilers, Compilers...

Charles — Wed, 11 Apr 2007 18:09:56 GMT

John Gough is a world famous writer of books and text books on Compilers - as well as being Professor xxx at Queensland University of Technology. He has been a part of the CLR and IL .NET project from a very early stage. One of his students, Joel Pobar, worked at Microsoft on parts of the dynamic parts of CLR/.NET added in version 2.0. Both of these esteemed gentlemen are in Brisbane, and Nick Hodge managed to interview them last week on compilers, functional and dynamic languages, history, learning, being geeks and the future of processors.