Channel 9

GoingNative 16: Garrett Serack - Inside NuGet for C++

Charles — Wed, 22 May 2013 14:51:16 GMT

NuGet support for C++ projects in Visual Studio has arrived in NuGet version 2.5! This has been an elusive feature for VC++ developers so we are thrilled it's here. It's been around for about a month now so we figured we'd go talk to one of the developers who helped make it happen, Microsoft's Garrett Serack.

Huge thanks to Garrett and the awesome NuGet team for bringing NuGet goodness to C++!

Download NuGet 2.5
Download the tools to build C++ packages

[00:00] GoingNative();// Charles and Ale construct the show. Sorry about missing last month! Milan update. NuGet.
[02:25] Charles interviews Garrett Serack about NuGet for C++
[39:04] ~GoingNative(); // Please send any and all feedback about NuGet for C++ to us!

More information:

NuGet Team blog post on NuGet for C++
VC++ Team blog post on NuGet for C++
Building Native Libraries for NuGet with CoApp's Powershell Tools (video)
Consuming Native NuGet Packages in Visual Studio (video)

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@hotmail.com. We will read and respond to all messages! That's how we roll, brothers and sisters. If you are a Facebook user (who isn't these days?), then please join our C9::GoingNative Facebook group.

Nikolai Tillmann and Peli de Halleux: Inside Code Digger

Charles — Tue, 07 May 2013 12:45:00 GMT

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.

Functional vs. Dynamic DSLs: The Smackdown

Charles — Mon, 06 May 2013 19:33:55 GMT

With the growing adoption of DSLs and DSL terminology into the mainstream has come a controversy over "external" (parser/AST/code-gen based) vs "internal" (hosted inside another programming language) DSLs. In this presentation, we take the approach that the complexity and power of an external DSL is hardly necessary for most DSL tasks, and that internal DSLs are the way to go. We discuss the difference between "compositional" and "computational" DSLs, a new way of thinking about constructing a DSL, and do so in the terms of two languages popularly used to host internal DSLs: Haskell (expressed mostly through F# code, owing to its functional nature) and Ruby (expressed mostly through Groovy code, owing to its dynamic nature).

Behavioral Testing DSLs for Automated Trading Systems

Charles — Mon, 06 May 2013 19:33:46 GMT

Equity and Equity Options exchanges (NYSE, NASDAQ, CBOE, etc.) support a version of the FIX messaging standard for sending market quotes and orders. While the mechanics of creating, sending, and responding to FIX based requests and tracking their lifecycle are fairly straightforward, it tends to be fairly cumbersome to create test scenarios for simulating market behavior for testing trading strategies and systems against as the knowledge required often rests with traders and financial engineers, not software developers. This talk would present a DSL using the SQL Server Modeling CTP (formerly"Oslo") toolset that is capable of expressing order generation and responses from a range of market behaviors in terms of FIX messages in a dialect suitable for use by traders and financial engineers.

Language Oriented Programming in F#

Charles — Mon, 06 May 2013 19:33:43 GMT

Roger Costillo will present one approach to Language Oriented Programming in F#, a technique in which software designers borrow techniques from language design to organize software architectures. In this approach, simple embedded DSLs called combinator libraries are explored. Roger will show two combinator libraries, one for managing a build process, the other for creating complex 3D visualizations. Attendees will see how the combinator library approach can be applied to these two very different problems. Essentially, a combinator library encourages the designer to break down a problem into elementary pieces and provide ways to recursively compose and reuse these pieces into an abstract description of a problem. Attendees will see a real world example of functional software design, see the use of DSLs and functional design to make the code more readable and provide modularity, see a demonstration of concise techniques for dealing with metadata in one tenth of the code and see how this obviates whole classes of runtime errors at compile time.

M DSLs: Deep Dive

Charles — Mon, 06 May 2013 19:33:29 GMT

A deep dive into the "M" parser generator and may even have some new features to talk about as well.

Textual DSLs and Code Generation with Eclipse Tools

Charles — Mon, 06 May 2013 19:33:22 GMT

As part of the Eclipse Modeling Project, a number of tools for defining DSLs and generating code have been developed over the last couple of years. In this talk, Markus will show a subset of these tools that have proven particularly useful. These include Xtext for definition of textual DSLs and editors, Check for defining constraints, as well as Xtend and Xpand for transforming models and generating code. Markus will motivate the approach by looking at how textual languages are used for software architecture modeling.

Intentional Software

Charles — Mon, 06 May 2013 19:33:09 GMT

Intentional Software is pioneering a radical new software approach that separates business domain knowledge from software engineering knowledge. This approach accelerates software creation and maintenance as domain experts themselves contribute domain knowledge in their favorite domain language and notation. Business domain knowledge is weaved into running software through domain transformations.

Practical Groovy Domain Specific Languages

Charles — Mon, 06 May 2013 19:32:34 GMT

Groovy's a JVM-based dynamic language, with a Java-like syntax that was made pretty flexible for DSLs.

Gilad Bracha: Embedding DSLs in Newspeak - EBNF, Hopscotch, and NewShell

Charles — Mon, 06 May 2013 19:32:15 GMT

Newspeak is a new programming language particularly suited to supporting DSLs, both internal and external. Newspeak's syntax is a natural fit for internal DSLs, which can leverage the language's powerful modularity and reflection. An important internal DSL is a BNF/PEG variant that is actually a powerful parser combinator library, that helps build external DSLs.

Pixel Bender: A DSL for Image Processing

Charles — Mon, 06 May 2013 19:32:09 GMT

Pixel Bender is a domain specific language for image processing algorithms (cool effects). The most important part of a Pixel Bender program is a function which given a location returns the color and transparency of the pixel at that location. This is a textbook parallel problem and therefore lends itself to vastly increased speedups using the wide parallelism of modern GPU hardware and multi-core CPUs. By creating a DSL, associated compilers, and runtime framework, it is possible to easily add effects to products such as Adobe Photoshop and Adobe After Effects.

JavaScript DSLs for the Client Side

Charles — Mon, 06 May 2013 19:32:03 GMT

This presentation will feature introductory material on JavaScript Metaprogramming, how these concepts map to the popular toolkits and frameworks (jQuery, Dojo, etc) and future directions for this work.

Martin Fowler: Introducing Domain-Specific Languages

Charles — Mon, 06 May 2013 19:31:57 GMT

As Martin Fowler begins to see the light at the end of the tunnel on drafting his DSL book, he's been prone to give more talks introducing DSLs. While he wouldn't consider it appropriate to give such a talk at this august gathering, he did think it would be interesting to do a meta-talk version of his introductory talk. For this he'll walk through the same material, but instead talk about why he thinks the approach he takes to an introduction is a useful way to guide people in their approach to DSLs.

Miguel de Icaza: Mono, Open Source, Visual Studio, and Xamarin

Charles — Wed, 24 Apr 2013 16:38:34 GMT

At Xamarin Evolve 2013, I caught up with Xamarin CTO Miguel de Icaza after his keynote. It's been a while since I last chatted with Miguel, so it was great to catch up. Clearly, he and team have been very busy pushing Mono forward and building Xamarin—a new technology that enables developers to target multiple platforms by writing apps in C# and .NET. During his keynote, Miguel announced that F# is now a part of the Xamarin family, too.

Xamarin ships with a Visual Studio plugin, making it possible to write iOS and Android apps on Windows using the best IDE in the world. Of course, VS natively supports the development of Windows and Windows Phone .NET apps, so you can imagine that Xamarin makes it possible for .NET developers to target all major mobile platforms, sharing as much core code as possible across them - effectively enabling C# to be everywhere you want it to be.

Here, we learn why Miguel et al. started Mono, how they ended up at Xamarin, and, potentially, where they're heading in the future with their excellent cross platform development technologies based on .NET. We talk about open source and proprietary software today, Visual Studio, and more. This is a Channel 9 interview, so it goes as it went. The only editing was cosmetic, not topical. Tune in.

It was a real pleasure to attend Evolve 2013. The Xamarin team pulled off an excellent event. It certainly didn't feel like an inaugural developer conference. Great production!

Huge thanks to Miguel for spending time with Channel 9. We'll make sure to get him in front of Camera 9 again soon.

GoingNative 15: VC++ turns 20, Ale turns 40, C9 turns 9

Charles — Thu, 21 Mar 2013 21:01:29 GMT

Visual C++ turned 20 this month! It certainly has come a long way. How did it begin? What were the goals way back when? Fortunately for us, one of the original team members VC++ team members, Jan Gray, set up a reunion of former and current employees who worked on the first visual IDE for C++ from Microsoft. During one of the related gatherings, Jan and fellow original VC++ alum, Rico Mariani, joined us for a casual chat about the early days of VC++. This conversation is full of goodness and a few surprises. Congratulations to the VC++ team and to all who shaped and continue to shape the product, from VC++ 1.0 to VC++11 - and that includes you, too!

It's no coincidence that as VC++ turned 20, Ale turned 40, and Channel 9 turned 9. Or is it? What's the hidden meaning in the sequence 20 40 9? Certainly something special! Happy birthday to all!!! And a big thank you to all of you who use Visual C++.

[00:00] GoingNative(); //We filmed this episode on Ale's 40th, VC++'s 20th, and C9's 9th birthday!!
[02:26] Rico Mariani and Jan Gray reminisce about the very early days of VC++
[46:11] ~GoingNative();

Immo Landwerth and Andrew Arnott: Inside Immutable Collections

Charles — Tue, 19 Mar 2013 18:08:54 GMT

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
ImmutableQueue
ImmutableList
ImmutableHashSet
ImmutableSortedSet
ImmutableDictionary
ImmutableSortedDictionary

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

Introduction to Office Developer Tools for Visual Studio 2012

Charles — Mon, 18 Mar 2013 17:43:58 GMT

With Office and SharePoint 2013, you can now build a new class of apps that extend and personalize the way we create and consume information.

Develop apps as web applications. You can use HTML and JavaScript for client-side code, and your choice of language for server-side code, such as VB.NET, C#, or PHP. Use your favorite tools and hosting environment to develop, test, and deploy your app.

Apps can interact with Office thanks to a new JavaScript API, consistent across multiple Office applications. Take advantage of OAuth support in SharePoint, along with a new set of REST APIs, to connect and interact with SharePoint while hosting your app in the cloud.

Finally, publish and sell your apps through the Office and SharePoint Store or distribute IT-approved apps through an internal App Catalog

Sean Laberee, Lead Program Manager on the Office Tools for Visual Studio team, introduces, explains, and demos the new VS tools for Office and Sharepoint app development. It's now easier than ever to build Office and SharePoint apps. Tune in.

Download Office Developer Tools for Visual Studio

Channel 9 turns 9!

Fri, 15 Mar 2013 13:00:00 GMT

From our humble beginnings as a website built with alpha quality forum technologies that we stitched together with creative code and a lot of love, and our videos were made by a few dudes roaming the halls of Microsoft with a cheap camcorder – look at us now. Channel 9 streams live events to 100,000s of people around the world, we have a state of the art recording studio, we do C9 Live at events around the world bringing you directly into the conversation with Microsoft folks in real time. Today, much of our content is created from folks around the company. Channel 9 is THE place to watch MS events on demand and to learn about our technologies from the people who make them – people are the lifeblood of software and technology. Channel 9 is people!

Today marks 9 years of 9. It's a very special day. We are especially humbled and honored to still be around given the change rate of the web. We thank all past, present and future Niners for the excellent conversations, arguments, debates, entertainment, and camaraderie. 9 Years of 9. That rolls so nicely off the tongue. Here's to 9 more.

Three Essential Tips For Async - Introduction

Charles, Lucian Wischik — Tue, 12 Mar 2013 13:00:00 GMT

Async involves some new concepts. They're not difficult; just unfamiliar. Over the past year Lucian Wischik has been watching how people use async/await in C# and VB. This series distils out the three top async patterns and anti-patterns.

Tips:

If you understand the basic flow of control in an async method, then those three points all fall naturally into place. This first introduction video explains that control flow.

Slides and source code are available on Lucian's blog.

Tip 1: Async void is for top-level event-handlers only

Charles, Lucian Wischik — Tue, 12 Mar 2013 13:00:00 GMT

Async Tip #1: Async void is for top-level event-handlers only, and event-like things. Don't use it elsewhere in your code.

Slides are available on Lucian's blog.

Async void is a "fire-and-forget" mechanism: the caller is unable to know when an async void has finished, and the caller is unable to catch any exceptions from it. The only case where this kind of fire-and-forget is appropriate is in top-level event-handlers. Every other async method in your code should return "async Task".

This video goes into some more difficult cases like the Win8 example "overrides async void LoadSettings()". Here you're overriding the method, and can't change the signature, and can't return a Task from it. The solution is to return a Task some other way, like through a field.

The video also talks about the thorny problem of async void lambdas. WHENEVER you see an async lambda, you need to verify whether it will be a void-returning or Task-returning lambda.

Tip 2: Distinguish CPU-Bound work from IO-bound work

Charles, Lucian Wischik — Tue, 12 Mar 2013 13:00:00 GMT

Async Tip #2: It's crucial to distinguish CPU-bound work (should be done on threadpool) from IO-bound work (which needn't).

You can download slides for this talk from Lucian's blog.

I remember reading an old Android dev blog post. It said: "1. A good practice in creating responsive applications is to make sure your main UI thread does the minimum amount of work. 2. Any potentially long task that may hang your application should be handled in a different thread. 3. Typical examples of such tasks are network operations, which involve unpredictable delays."

There's a serious flaw in this logic... When your program is just sitting there twiddling its thumbs, waiting for a network packet to come back, it's not doing any work, and so doesn't need to go on a background thread. You should await it instead!

Await opens up a whole new simpler world of programming. You can mostly get by without any background threads at all. That means all of your code can run on the UI thread, which makes it much easier to do databinding, to update the UI, and so on.

Await also improves responsiveness of servers. That's because the threadpool takes some time to ramp up. If you use await, then you can ramp up instantly.

So when do you need to use the threadpool, and how? Answer: only when you've got some CPU-bound work, like a compute-bound iteration over a large dataset; and do it using Parallel.ForEach or Task.Run.

Tip 3: Wrap events up in Task-returning APIs and await them

Charles, Lucian Wischik — Tue, 12 Mar 2013 13:00:00 GMT

Async Tip #3: You can wrap events up in Task-returning APIs and await them. This can dramatically simplify code.

Slides and source code are available on Lucian's blog.

This video introduces a new pattern for dealing with events: you can await them! Now why would you want to do that? Well, in some cases like responding to a button-click, it's fine to handle events in the way that you always have with top-level event handlers. But if you're building a complicated UI that has to orchestrate a whole load of events (StoryboardCompleted, MediaElementCompleted, PointerMoved, PointerReleased, ...) then it makes for cleaner code to await them. The key is the type TaskCompletionSource introduced in .NET4.

GoingNative 14: Image Processing, Image Watch, Exceptions

Charles — Tue, 05 Mar 2013 23:46:40 GMT

You recently learned about Image Watch, a Visual Studio 2012 plug-in for visually debugging (watch window, locals, etc...) image processing code in C++. How does it work? What does the implementation look like (or how was it designed, how much modern C++ does it employ, how old is the code base, etc...). You can't talk about shared libraries in C++, ones that have been around for a while, without talking about exceptions. You either love them or hate them and the Image Watch developers have internal customers (devs inside Microsoft) that either love them or hate them... We geek out on that for a while, of course.

Overall, if you want to understand Image Watch more deeply and meet some great C++ developers who work at Microsoft doing very innovative things (in Microsoft Research, specifically) with C++, then this is for you! Rock and roll.

Big thanks to Wolf Kienzle and Matt Uyttendaele for riding tandem with the random with us.

Tune in!

[00:00] GoingNative(); // Charles and Eric Battalio construct the show
[02:54] Charles and Eric interview Image Watch developers Wolf Kienzle and Matt Uyttendaele
[43:09] ~GoingNative();// Charles and Eric destruct this instance (no exceptions, of course).

Tomas Petricek: How F# Learned to Stop Worrying and Love the Data

Charles — Mon, 04 Mar 2013 17:33:06 GMT

Tomas Petricek, a PhD student at University of Cambridge focusing on programming models, teaches us about one of his favorite programming languages, F#. The main topic is programming data with F#. You'll learn about Type Providers and Tomas will show how you can easily call REST APIs from F# using type providers and how you can access WorldBank data, but with a slight twist. All the code will be fully translated to JavaScript and will run in any web browser.

Tomas has provided a library of type providers you can use to experiment with what you learn here.

Introducing Image Watch - A VS 2012 Plug-In for C++ Image and Video Debugging

Charles — Wed, 27 Feb 2013 18:24:22 GMT

Image Watch is a new Visual Studio 2012 plug-in for debugging C++ image and video processing applications, for example photo or augmented reality apps. Image Watch provides a watch window that can display in-memory bitmaps during debugging, so you no longer need to litter your code with "save-this-intermediate-image-to-a-file" statements when tracking down bugs. The initial release has built-in support for OpenCV image types and can be extended for viewing user-defined image types as well.

Here, Wolf Kienzle, Senior Research Developer, Interactive Visual Media group, Microsoft Research Redmond, explains and demos this excellent new tool for C++ developers building image, video or augmented reality apps. In effect, you can step into pixels. Excellent!