Going Deep (HD) - Channel 9

Herb Sutter presents C++ Concurrency. This was filmed at C++ and Beyond 2012. Get Herb's slides for this session. Herb says: I've spoken and written on these topics before. Here's what's different about this talk: Brand new: This material goes beyond what I've written and taught about before in my Effective Concurrency articles and courses. Cutting-edge current: It covers the best-practices state of the art techniques and shipping tools, and what parts of that are standardized in C++11 already (the answer to that one may surprise you!) and what's en route to near-term standardization and why, with coverage of the latest discussions. Blocking vs. non-blocking: What's the difference between blocking and non-blocking styles, why on earth would you care, which kinds does C++11 support, and how are we looking at rounding it out in C++1y? The answers all matter to you – even the ones not yet in the C++ standard – because they are real, available in shipping products, and affect how you design your software today.

Dr. Marko A. Rodriguez is the Founder and CEO of the graph technology firm Aurelius and creator of the graph traversal language Gremlin. He has focused his academic and commercial career on graph theory, network science, and graph-system architecture and development.Here, we learn about graph systems, database architectures, and high level graph theory. Tune in. Lots to learn!

The Windows heap manager has been around as long as Windows has, evolving with each release, getting faster, more reliable, and more secure. In Windows 8, the heap manager improves in two major areas: performance and security. In this video, Greg Colombo, a developer on the Windows kernel team working on the Windows heap manager, digs into the details. What are the changes that positively impact performance and security?This conversation—conducted entirely at the whiteboard—provides enough introductory information to ensure that even if you have no idea what a heap manager is—or what the heap is, for that matter—you will after you watch this. The complexity in this discussion increases over time, but remains understandable all the way through. Greg is an excellent communicator! Huge thanks to Greg for taking the time to educate us.Tune in. Learn.

Andrei Alexandrescu presents "Systematic Error Handling in C++". This was filmed at C++ and Beyond 2012 Abstract: Writing code that is resilient upon errors (API failures, exceptions, invalid memory access, and more) has always been a pain point in all languages. This being still largely an unsolved (and actually rather loosely-defined) problem, C++11 makes no claim of having solved it. However, C++11 is a more expressive language, and as always more expressive features can be put to good use toward devising better error-safe idioms and libraries. This talk is a thorough visit through error resilience and how to achieve it in C++11. After a working definition, we go through a number of approaches and techniques, starting from the simplest and going all the way to file systems, storage with different performance and error profiles (think HDD vs. RAID vs. Flash vs. NAS), and more. As always, scaling up from in-process to inter-process to cross-machine to cross-datacenter entails different notions of correctness and resilience and different ways of achieving such. To quote a classic, "one more thing"! An old acquaintance—ScopeGuard—will be present, with the note that ScopeGuard11 is much better (and much faster) than its former self.Tune in. Learn. Thanks to Andrei, Herb and Scott for inviting C9 to film these wonderful sessions, rife with practical technical information for modern, professional C++ developers. Get the slides.

Continuing with our series of conversations with engineers in Windows, we meet Pedro Teixeira, a software developer on the Windows kernel team (aka core OS) who has improved the Windows thread pools in Windows 8. Thread pools are thread management subsystems (user mode and kernel mode) where threads are created and queued for any number of arbitrary tasks (work) required by applications and services. As it turns out, there are some significant improvements to the thread pool pattern in Windows 8. Pedro takes the time necessary - at the whiteboard for the entire interview - to dig into the details, beginning with first principles. So, if you don't really know what a thread pool is, then you will after the first 5 minutes of this interview. As the conversation progresses, the complexity will increase, but will remain suitable for most user mode application developers. Speaking of user mode, much of the time in this interview is spent on the Windows 8 user mode thread pool. The kernel mode thread pool is addressed towards the end of the conversation.In Windows 8, there is a new thread pool model and new thread creation policy. What is the new policy? How is the new user mode thread pool designed? How is it better than its predecessors? What does this all mean for developers? Tune in. Learn. Huge thanks to Pedro for taking the time to dig in - and for explain things in such a clear way.

Arun Kishan digs into the low level details of Windows 8's new application model. How has Process Lifetime Management (PLM) been reimagined in Windows 8? How does app suspension work, exactly, or, what happens when an app is no longer in the foreground and not closed? How much work can you do in the background when an app is suspended? Arun covers several topics here, so please do set aside some quality time. In return, you will gain new levels of deep understanding that will help you take advantage of the Windows Store App platform and build excellent modern Windows applications.You've met Arun before, so you should be prepared for some very deep treatment of this new world for Windows and Windows developers. This is an excellent 400 level investigation of the core changes that support the new app model. Huge thanks to Arun for another exceptional conversation and whiteboard session. Tune in. Learn.

By now you've learned that the CLR, Windows Phone Client, and Windows Phone Services teams got together to develop "Compiler in the Cloud". All Windows Phone 8 apps written in .NET technologies will get the benefit of this collaboration. The end goal? Really fast startup of Windows Phone 8 .NET apps. "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 Dee

Technical Fellow Steve Lucco (architect and lead engineer of IE's Chakra JS VM) and Google's V8 and Dart architect Lars Bak discuss JavaScript, from a virtual machine perspective (implementer's view point). IE and Chrome employ different strategies (although they do share some things in common) to make JavaScript execute faster. What are these strategies? How do Chakra and V8 differ? How are they similar? How fast can Lars and Steve make JavaScript go, anyway? What's the speed limit for JavaScript execution? What languages are used to write these VMs? (Hint, both start with C...)This is a candid technical conversation among two excellent software engineers tasked with making JavaScript run as fast as possible in their respective JS VMs. The conversation also includes a brief discussion on open source technologies. 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!).

TypeScript, a typed superset of JavaScript that compiles to idiomatic (normal) JavaScript, is designed to make it easier to write cross-platform, application scale, JavaScript that runs in any browser or in any host. It was announced recently while Anders Hejlsberg and other key members of the TypeScript team were attending and speaking at the goto conference (an excellent cross-platform developer event!). Needless to say, Channel 9 was there Google's V8 and Dart chief architect Lars Bak also happened to be at the event (he's currently leading the Dart team full time). Anders and Lars join us to talk candidly about TypeScript, JavaScript and Dart. Huge thanks to Anders and Lars for this excellent conversation. Tune in. Enjoy.

Scott Meyers presents "Universal References in C++11". This was filmed at C++ and Beyond 2012. This is the full session in all of its splendor. Huge thanks to Scott for allowing C9 to provide this excellent C++11 content to the world. From Scott's recently published article in the October 2012 edition of ACCU's Overload: Given that rvalue references are declared using "&&", it seems reasonable to assume that the presence of "&&" in a type declaration indicates an rvalue reference. That is not the case: Widget&& var1 = someWidget; // here, "&&" means rvalue reference

auto&& var2 = var1; // here, "&&" does not mean rvalue reference

template

void f(std::vector&& param); // here, "&&" means rvalue reference

template

void f(T&& param); // here, "&&" does not mean rvalue reference

In this article, I describe the two meanings of "&&" in type declarations, explain how to tell them apart, and introduce new terminology that makes it possible to unambiguously communicate which meaning of "&&" is intended. Distinguishing the different meanings is important, because if you think "rvalue reference" whenever you see "&&" in a type declaration, you'll misread a lot of C++11 code. Tune in. Scott's an incredible presenter and it's well worth your time to both read his article and watch his presentation on the subject. Great stuff! Download slides