Developers · Best
Going Deep (HD) - Channel 9
By Microsoft
About this podcast
Charles Torre travels around Microsoft to meet the company’s leading Architects and Engineers to discuss the inner workings of our core technologies. Going Deep is primarily concerned with how things work, why they are designed the way they are, and how they will evolve over time. Going Deep also includes lectures by domain experts and conversational pieces amongst computer scientists, architects and engineers (a la E2E).
Episodes (Total: 10)
Sept. 10, 2014 · 00:56:34
It's always great to spend some time geeking out with Bart De Smet. As usual, he has a lot of technical details to share and only so much whiteboard real estate. Bart is still deeply engaged with Rx (evolving it, putting it to new uses, making it even more general and capable). How so, you ask?Well, ask Cortana. She will tell you that, in fact, Rx is one those wonderful things that make her so asynchronously capable and reliable at managing your calendar and the growing list of other personal things that you have her do for you. (I haven't actually asked Cortana this, so this is an exercise for the reader...)Bart, how exactly is Rx used in Cortana?Remember our old friend IQbservable?Look, a whiteboard! (But, of course, we have catching up to do beforehand. Be patient.)Tune in. Enjoy.
April 2, 2014 · 00:39:34
What happens when .NET code is statically compiled to machine code (versus runtime compiled via JIT) by the VC++ back end compiler? You get highly optimized binaries that load and run faster than .NET code ever has before. Yes, my friends, .NET has gone native! :) Today, the .NET team is releasing a preview of their new compiler technology, .NET Native. You can generate .NET native binaries for Windows Store apps only (in this preview). Tune in and meet a few key members of the .NET Native team, PM Mani Ramaswamy and Dev Lead Shawn Farkas. We go deep and Shawn spends quality time at the whiteboard. The team has done a lot of work to get where they are today and no part of .NET has gone untouched, from a new CLR to optimized BCL. This project is a natural extension of the MDIL work that was done for Windows Phone 8. It's all about highly optimized .NET for modern hardware - that the VC++ back end is turning IL into highly optimized machine code is a very, very good thing - for developers and, especially, users! Note: Shawn and a fellow engineer will be on C9 Live at build on Day 3, so please watch this and prepare questions to ask them live, right here on C9 (details to follow).Go native!
May 7, 2013 · 00:32:44
Code Digger is a lightweight version of Pex that allows you to explore public .NET methods in Portable Libraries directly from the Visual Studio 2012 code editor. It's a highly simplified and nifty way to leverage the power of Pex and Z3, one of the world's fastest constraint solvers.So, how does Code Digger actually work? Why the PCL requirement? What happens when you click on the magic button, Alice?Nikolai Tillmann and Peli de Halleux, software developers extraordinaire on MSR's RiSE team, join us again to dig into Code Digger in a casual setting (Nikolai's office, so native habitat). There is lots of geeking out at the whiteboard, of course. There is also a brief demo at the end. Tune in. 
March 19, 2013 · 00:54:18
Immutable Collections are a new set of immutable types for .NET. We covered the high level aspects of this new technology a few months back when Erik Meijer interrogated (in his friendly way) the PM of the project, Immo Landwerth, and the lead developer, Andrew Arnott. Since this time, they have received a lot of feedback (thank you!) and have also been busy refining and optimizing their code. Here, Andrew and Immo go deep into how this stuff works and why it's designed the way it is. We talk about how to use these new types and how not to. We learn what the team has been working on and may work on for future releases. As is the case with any Going Deep episode, this is long form conversation and, well, deep. Tune in!More on Immutable Collections (download the preview versions via NuGet): The NuGet package preview includes these types: ImmutableStack<T> ImmutableQueue<T> ImmutableList<T> ImmutableHashSet<T> ImmutableSortedSet<T> ImmutableDictionary<K, V> ImmutableSortedDictionary<K, V> Interfaces for each of these types are also defined to facilitate exchange of immutable collection types that may be implemented differently to optimize for very specific performance or memory requirements. See Andrew's blog for more detailed information (on immutable types for .NET and more. Lots of great info...).
Feb. 20, 2013 · 00:44:51
ActorFx is an MSOpenTech open source project with the goal of providing a non-prescriptive, language-independent model of dynamic distributed objects. This will in turn provide a framework and infrastructure on top of which highly available data structures and other logical entities can be implemented. ActorFx (aka Ax) is based on the idea of the Actor Model developed by Carl Hewitt. Erik Meijer figured this model would fit perfectly into the realm of managing data in the cloud. See his paper on the topic, which is the basis for the ActorFx project. You can learn more about the Actor Model in this Channel9 video with Carl and Erik. Here, the lead developers of ActorFx - Brian Grunkemeyer and Joe Hoag - join us to dig into some of the details of the technology. We also discuss the potential of Actors in the cloud, the problems they solve, how you program with them on the client (CloudList<T> is an interesting "cloud-enabled" type, for example), and potential applications of this approach to scalable distributed computing.
Feb. 11, 2013 · 01:32:33
Herb Sutter presents atomic<> Weapons, 2 of 2. This was filmed at C++ and Beyond 2012. As the title suggests, this is a two part series (given the depth of treatment and complexity of the subject matter). STOP! => Watch part 1 first! Download the slides. Abstract: This session in one word: Deep. It's a session that includes topics I've publicly said for years is Stuff You Shouldn't Need To Know and I Just Won't Teach, but it's becoming achingly clear that people do need to know about it. Achingly, heartbreakingly clear, because some hardware incents you to pull out the big guns to achieve top performance, and C++ programmers just are so addicted to full performance that they'll reach for the big red levers with the flashing warning lights. Since we can't keep people from pulling the big red levers, we'd better document the A to Z of what the levers actually do, so that people don't SCRAM unless they really, really, really meant to. Topics Covered: The facts: The C++11 memory model and what it requires you to do to make sure your code is correct and stays correct. We'll include clear answers to several FAQs: "how do the compiler and hardware cooperate to remember how to respect these rules?", "what is a race condition?", and the ageless one-hand-clapping question "how is a race condition like a debugger?"The tools: The deep interrelationships and fundamental tradeoffs among mutexes, atomics, and fences/barriers. I'll try to convince you why standalone memory barriers are bad, and why barriers should always be associated with a specific load or store.The unspeakables: I'll grudgingly and reluctantly talk about the Thing I Said I'd Never Teach That Programmers Should Never Need To Now: relaxed atomics. Don't use them! If you can avoid it. But here's what you need to know, even though it would be nice if you didn't need to know it.The rapidly-changing hardware reality: How locks and atomics map to hardware i
Feb. 11, 2013 · 01:21:12
Herb Sutter presents atomic<> Weapons, 1 of 2. This was filmed at C++ and Beyond 2012. As the title suggests, this is a two part series (given the depth of treatment and complexity of the subject matter). Part 1 -> Optimizations, races, and the memory model; acquire and release ordering; mutexes vs. atomics vs. fences Download the slides. Abstract: This session in one word: Deep. It's a session that includes topics I've publicly said for years is Stuff You Shouldn't Need To Know and I Just Won't Teach, but it's becoming achingly clear that people do need to know about it. Achingly, heartbreakingly clear, because some hardware incents you to pull out the big guns to achieve top performance, and C++ programmers just are so addicted to full performance that they'll reach for the big red levers with the flashing warning lights. Since we can't keep people from pulling the big red levers, we'd better document the A to Z of what the levers actually do, so that people don't SCRAM unless they really, really, really meant to. Topics Covered: The facts: The C++11 memory model and what it requires you to do to make sure your code is correct and stays correct. We'll include clear answers to several FAQs: "how do the compiler and hardware cooperate to remember how to respect these rules?", "what is a race condition?", and the ageless one-hand-clapping question "how is a race condition like a debugger?"The tools: The deep interrelationships and fundamental tradeoffs among mutexes, atomics, and fences/barriers. I'll try to convince you why standalone memory barriers are bad, and why barriers should always be associated with a specific load or store.The unspeakables: I'll grudgingly and reluctantly talk about the Thing I Said I'd Never Teach That Programmers Should Never Need To Now: relaxed atomics. Don't use them! If you can avoid it. But here's what you need to know, even though it would be nice if you didn't need to
Jan. 14, 2013 · 00:41:14
Chris Stevens is a software developer on the Windows kernel team working on the Windows boot environment. Windows 8 boots faster than any other version of Windows. Why? How? Chris begins with the fundamentals (so, if you don't know anything about the boot process or what actually happens when an OS like Windows starts up, then you will after watching this...) and then digs into how the boot experience/environment/process was has evolved in Windows 8.Tune in!
Jan. 7, 2013 · 00:45:50
Jon Berry, a veteran Windows engineer, digs into the new way Windows 8 manages processes to support the brave new world of Windows running on various CPU architectures including ARM and ATOM, which present an interesting set of technical challenges given the need to aggressively preserve energy when running—yet not fully running—while in a battery-powered state. Jon owns the Desktop Activity Moderator (DAM), which, as the name implies, moderates desktop processes. The DAM is one of several new features in Windows 8 designed to ensure consistent, long battery life for devices that support connected standby. Connected standby occurs when the device is powered on but the screen is turned off. In this power state, the system is technically always "on" (to support key scenarios like mail, VoIP, social networking, and instant messaging with Windows Store apps). It is analogous to the state a smart phone is in when the user presses the power button. As such, software (including apps and operating system software) must be well-behaved during connected standby. The DAM was created to suppress desktop app execution in a manner similar to the Sleep state. It does this by suspending or throttling desktop software processes across the system upon connected standby entry. This enables systems that support connected standby to deliver minimized resource usage and long, consistent battery life while enabling Windows Store apps to deliver the connected experiences they promise. The DAM is a kernel mode driver that is loaded and initialized at system boot if the system supports connected standby. How does Windows 8 provide this always-on experience and not drain the battery in 10 minutes? What does the DAM actually do? How does it work? The DAM is part of a larger management system, which Jon also describes here. What is connected standby, exactly? Jon spends a lot of time at the whiteboard answering these and other questions. Thank you, Jon! Tune in. Learn.
Jan. 4, 2013 · 01:15:38
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.