As usual, this is a conversation. We cover a fair amount of ground and take turns into interesting rabbit holes when they present themselves. It's always great to talk with Anders, Steve and Luke; great folks.

Learn more here:

TypeScript Team blog
Soma's blog

[00:00]  GoingNative();\\ Charles and Ale discuss C++ at Build 2012 and introduce Profile Guided Optimization.

[04:09]  Charles interviews VC++ back end compiler team members Ten Tzen (lead developer) and Amit Mohindra (PM) about VC++'s implementation of PGO. Whiteboarding included. This is a long interview, so make some time.

[01:04:15]  ~GoingNative(); // Charles and Ale reflect on PGO, Charles answers Herb Sutter's question (that Herb asked Charles during his Build 2012 C++ session (in his intro remarks). Hi Herb!

We really want to hear from you, so please tweet feedback to @C9GoingNative (follow us!) and send your requests, ideas, complaints, praises, hate mail, and love letters to C9GoingNative at hotmail com. We will read and respond to all messages! That's how we roll, brothers and sisters. If you are a Facebook user, then please join our C9::GoingNative Facebook group.

Go native!

"Compiler in the Cloud?", you ask. 

The idea is pretty simple. First, enter MDIL or Machine Dependent Intermediate Language or .NET hybrid assembly language. MDIL is all about compiling to native assembly instructions whenever possible, and compile the rest to pseudo instructions that can quickly be translated to native instructions on the phone. Thus, this assembly containing a mix of pseudo instructions and native instructions can be shipped to the device (and is portable across the same architecture - example, across all the ARM devices), and on the device we perform a light-weight linking step to convert the entire assembly to a native image. Most of the heavy lifting is done when we compile the IL assembly to the intermediate file between an IL assembly and a native image (this is what MDIL is).

"So what?", you ask. The linking step on the device that converts MDIL assembly to a native image only takes 1/5th the time as traditional NGEN on device. Thus, we get some of the benefits of both pre-compilation (since we are executing off the native image where all instructions are assembly instructions) and JIT-compilation (no heavy compilation on the device during framework updates).

Tune in to meet the program manager for code generation in .NET, Subramanian (Mani) Ramaswamy, and one of the lead developers of "Compiler in the Cloud", Peter Sollich. Peter is an expert in precompilation. We go quite deep here with plenty of whiteboarding. Peter teaches us exactly what MDIL is and why it's designed the way it is. We also talk about the higher level meaning in this (apps start fast, at native speed!). All around, it's a great Going Deep episode. Take the time to watch and learn. Thanks Mani and Peter!!

See Subramanian's BUILD 2012 session where he goes into detail on MDIL/Compiler in the Cloud and other performance/functionality improvement in .NET for Windows Phone 8.

"With Multicore JIT, methods are compiled on two cores in parallel. The more code you execute on your startup path, the more effective Multicore JIT will be at reducing startup time. Improvements of 20%-50% are very typical, which is great news to anyone developing medium to large .NET Framework applications that are not able to take advantage of NGen. You can improve the startup time of your application by up to 50% with very little work, even if it runs off of a USB stick."

Who better to explain this than .NET Performance Architect Vance Morrison and Multicore JIT program manager Dan Taylor? They are joined by software engineer Rick Brewster from the Windows team to discuss how this technology works and why it matters. Rick works on a large .NET Windows desktop application and Multicore JIT has clearly sped up his app's startup time. We'll get the inside scoop from both those who designed the technology and those who use it in production.

This was filmed at GOTO Aarhus 2012, an excellent developer event. Huge thanks to Lars and Steve for the excellent conversation and to the folks at GOTO for providing a room for me for all these interviews (and lights, too!).

In the first part of this n-part series, Jim introduces the series, describes improvements to the VC++ 2012 compilers, shares, introduces auto-vectorization, demos a few apps that benefit from compiler-optimized performance via auto-vectorization, and begins to describe how/when user code is vectorized (typical and atypical patterns alike - more to come as the lectures progress, of course). Over the course of this series, Jim will present both the practical and theoretical foundations of auto-vectorization.

(You can learn more about auto-vectorization in VC++ by reading the blog posts by Jim Hogg, another member of the VC++ compiler team working on this technology.)

Tune in. Ask questions. Learn.

In order to keep the conversation palatable to a large number of folks, we don't get into the math behind auto-vectorization. However, if this is something that really interests you, then we can get Jim to do a lecture on the internals (will take more than one session, of course—a lot of stuff goes on behind the scenes when you take a loop of arbitrary complexity and determine if it's vectorizable and then vectorize it with maximum efficiency...). Now, on to AutoVec.

The VC11 compiler includes a feature called Auto-Vectorization, or AutoVec for short. AutoVec tries to make loops in your code run faster by using the SSE, or vector, registers present in all current processors. The feature is on by-default. So, like other optimizations that the compiler performs, you don't need to know anything more to benefit.  However, this session explains more background on what is going on, and digs a little into the kinds of sophisticated analyses that AutoVec performs, and the loop patterns that it successfully speeds up.

Here's a trivial example of a loop that gets automatically vectorized in VC11 with significant performance gains:

int i = 0;
for (i=0; i<100000; i++)
{
    a[i] = b[i] + c[i];
}

The auto-vectorizer transforms the above tight loop into machine instructions that run the loop 4x faster on SIMD-capable (SSE/SSE2) processors. As Jim and Jim discuss, this is because each loop iteration simultaneously  performs 4 computations using the modern CPU's vector registers. This is a great automatic optimization feature in VC11. Tune in and meet a couple of the key folks behind VC's Auto-Vec!

Table of Contents:

[00:00] Diego and Charles construct the show (C++NOW, Some news, Auto-Vectorizer in VC11 compiler)
[04:45] Charles interviews VC backend compiler lead developer Jim Radigan and backend compiler PM Jim Hogg
[52:03] Diego and Charles destruct the show (longer than usual, but worth the delay - Lang.NEXT, C&B 2012, C++ + XAML + DX, WRL Documentation)

The Roslyn CTP previews the "next generation of language object models for code generation, analysis, and refactoring, and the upcoming support for scripting and interactive use of VB and C#."

Here, we meet the Roslyn Project design team (and the authors of the The Roslyn Project technical paper), Anders Hejlsberg, Karen Ng, Matt Warren, and Peter Golde. We discuss why Roslyn matters, how it works (briefly - we'll go deeper in the future), what it affords, and what it doesn't enable. This is a very interesting project and Roslyn promises to make Visual Studio code refactoring tools easier to build and potentially more powerful than they are today, but at a deeper level—Roslyn provides programmable access to a world class compiler infrastructure - language parser, semantic analyzer,etc - to managed developers (C#/VB).

It's an open question as to what you may actually end up doing with Roslyn if you are not, say, a visual tools developer, but that's the point of this random interlude (aka a Charles interview...though we do talk extensively about what Roslyn can be used for). With Roslyn, you have a lot of power and information at your disposal. How are you going to use it? What will you build?

Download the CTP, play around with Roslyn and provide feedback to the team. They want to hear from you!

Tune in and get a sense of what TAL is, how type verification works for assembly code, benefits, trade-offs, and much more. Enjoy.

Details and Download Page: http://msdn.microsoft.com/en-US/vstudio/async

Forum for Feedback and Questions: http://social.msdn.microsoft.com/Forums/en-US/async/threads

Many of you probably know Eric Lippert from his exceptional blog. You've also met him on C9 before (in fact, Eric was the very first interview Channel 9 shot almost 7 years ago—I remember Lenn, Jeff, Bryn, Scoble, and myself huddled around the computer in my office watching the video with Eric. It was clear we were on to something...).

But how much do you know about Eric? Where is he from? What attracted him to computers? When did he first start programming? What was the spark that lit the fire inside of him for writing code? How did he land at Microsoft? What projects has he worked on over the years? What's he working on these days?

Compilers have evolved to meet the modern needs of developers, and Eric, one of the developers of the C# compiler, knows this firsthand. From Intellisense to refactoring, compilers do much more than take syntax and convert it into an optimized language that a target execution layer can understand. Currently, the C# compiler is written in C++ and it's architecture is becoming outdated (not because of C++ mind you...). Eric et al are rebuilding the C# compiler from the ground up and they are writing the compiler in C#. Why? Why not stick with C++? Will there be performance penalties to pay for going managed? We talk about all of this, of course...

Erik has many questions for Eric. What will the answers be? Tune in.

Enjoy, and thanks to Eric for spending time with Erik and Channel 9! Great conversation, as usual.

Happy Birthday, Channel 9!!!

• Green Technical Report
• Green story on Microsoft Research

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.

• Try VCC in your web browser at http://rise4fun.com/vcc !
• 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.