Podcasts about winrt

This is Last Week in .NET for the week that ended 17 October 2020. Lots of releases and CVE fixes last week, so let's get to it.

Visual Basic Welcome to the History of Computing Podcast, where we explore the history of information technology. Because understanding the past prepares us for the innovations of the future! Today we're going to cover an important but often under appreciated step on the path to ubiquitous computing: Visual Basic. Visual Basic is a programming language for Windows. It's in most every realistic top 10 of programming languages of all time. It's certainly split into various functional areas over the last decade or so, but it was how you did a lot of different tasks in Windows automation and programming for two of the most important decades through a foundational period of the PC movement. But where did it come from? Let's go back to 1975. This was a great year. The Vietnam War ended, Sony gave us Betamax, JVC gave us VHS. Francisco Franco died. I don't wish ill on many, but if I could go back in time and wish ill on him, I would. NASA launched a joint mission with the Soviet Union. The UK voted to stay the EU. Jimmy Hoffa disappears. And the Altair ships. Altair Basic is like that lego starter set you buy your kid when you think they're finally old enough to be able to not swallow the smallest pieces. From there, you buy them more and more, until you end up stepping on those smallest pieces and cursing. Much as I used to find myself frequently cursing at Visual Basic. And such is life. Or at least, such is giving life to your software ideas. No matter the language, there's often plenty of cursing. So let's call the Altair a proto-PC. It was underpowered, cheap, and with this Microsoft Basic programming language you could, OMG, feed it programs that would blink lights, or create early games. That was 1978. And based largely on the work of John Kemeny and Thomas Kurts, the authors of the original BASIC in 1964, at Dartmouth College. As the PC revolution came, BASIC was popular on the Apple II and original PCs with QuickBASIC coming in 1985, and an IDE, or Integrated Development Environment, for QuickBASIC shipped in 2.0. At the time Maestro was the biggest IDE in use, but they'd been around since Microsoft released the first in 1974. Next, you could compile these programs into DOS executables, or .exe files in 3.0 and 4.0 brought debugging in the IDE. Pretty sweet. You could run the interpreter without ever leaving the IDE! No offense to anyone but Apple was running around the world pitching vendors to build software for the Mac, but had created an almost contentious development environment. And it showed from the number of programs available for the Mac. Microsoft was obviously investing heavily in enabling developers to develop in a number of languages and it showed; Microsoft had 4 times the software titles. Many of which were in BASIC. But the last version of QuickBASIC as it was known by then came in 4.5, in 1988, the year the Red Army withdrew from Afghanistan - probably while watching Who Framed Roger Rabbit on pirated VHS tapes. But by the late 80s, use began to plummet. Much as my daughters joy of the legos began to plummet when she entered tweenhood. It had been a huge growth spurt for BASIC but the era of object oriented programming was emerging. But Microsoft was in an era of hyper growth. Windows 3.0 - and what's crazy is they were just entering the buying tornado. 1988, the same year as the final release of QuickBASIC, Alan Cooper created a visual programming language he'd been calling Ruby. Now, there would be another Ruby later. This language was visual and Apple had been early to the market on Visual programming, with the Mac - introduced in 1984. Microsoft had responded with Windows 1.0 in 1985. But the development environment just wasn't very… Visual. Most people at the time used Windows to open a Window of icky text. Microsoft leadership knew they needed something new; they just couldn't get it done. So they started looking for a more modern option. Cooper showed his Ruby environment to Bill Gates and Gates fell in love. Gates immediately bought the product and it was renamed to Visual Basic. Sometimes you build, sometimes you partner, and sometimes you buy. And so in 1991, Visual Basic was released at Comdex in Atlanta, Georgia and came around for DOS the next year. I can still remember writing a program for DOS. They faked a GUI using ASCII art. Gross. VB 2 came along in 1992, laying the foundations for class modules. VB 3 came in 93 and brought us the JET database engine. Not only could you substantiate an object but you had somewhere to keep it. VB 4 came in 95 because we got a 32-bit option. That adds a year or 6 for every vendor. The innovations that Visual Basic brought to Windows can still be seen today. VBX and DLL are two of the most substantial. A DLL is a “dynamic link library” file that holds code and procedures that Windows programs can then consume. DLL allow multiple programs to use that code, saving on memory and disk space. Shared libraries are the cornerstone of many an object-oriented language. VBX isn't necessarily used any more as they've been replaced with OCXs but they're similar and the VBX certainly spawned the innovation. These Visual Basic Extensions, or VBX for short, were C or C++ components that were assembled into an application. When you look at applications you can still see DLLs and OCXs. VB 4 was when we switched from VBX to OCX. VB 5 came in 97. This was probably the most prolific, both for software you wanted on your computer and malware. We got those crazy ActiveX controls in VB 5. VB 6 came along in 1998, extending the ability to create web apps. And we sat there for 10 years. Why? The languages really started to split with the explosion of web tools. VBScript was put into Active Server Pages . We got the .NET framework for compiled web pages. We got Visual Basic for Applications, allowing Office to run VB scripts using VBA 7. Over the years the code evolved into what are now known as Unified Windows Platform apps, written in C++ with WinRT or C++ with CX. Those shared libraries are now surfaced in common APIs and sandboxed given that security and privacy have become a much more substantial concern since the Total Wave of the Internet crashed into our lego sets, smashing them back to single blocks. Yah, those blocks hurt when you step on them. So you look for ways not to step on them. And controlling access to API endpoints with entitlements is a pretty good way to walk lightly. Bill Gates awarded Cooper the first “Windows Pioneer Award” for his work on Visual Basic. Cooper continued to consult with companies, with this crazy idea of putting users first. He was an earlier proponent of User Experience and putting users first when building interfaces. In fact, his first book was called “About Face: The Essentials of User Interface Design.” That was published in 1995. He still consults and trains on UX. Honestly, Alan Cooper only needs one line on his resume: “The Father of Visual Basic.” Today Eclipse and Visual Studio are the most used IDEs in the world. And there's a rich ecosystem of specialized IDEs. The IDE gives code completion, smart code completion, code search, cross platform compiling, debugging, multiple language support, syntax highlighting, version control, visual programming, and so much more. Much of this isn't available on every platform or for every IDE, but those are the main features I look for - like the first time I cracked open IntelliJ. The IDE is almost optional in functional programming - but In an era of increasingly complex object-oriented programming where classes are defined in hundreds or thousands of itty bitty files, a good, smart, feature-rich IDE is a must. And Visual Studio is one of the best you can use. Given that functional programming is dead, there's no basic remaining in any of the languages you build modern software in. The explosion of object-orientation created flaws in operating systems, but we've matured beyond that and now get to find all the new flaws. Fun right? But it's important to think, from Alan Kay's introduction of Smalltalk in 1972, new concepts in programming in programming had been emerging and evolving. The latest incarnation is the API-driven programming methodology. Gone are the days when we accessed memory directly. Gone are the days when the barrier of learning to program was understanding functional and top to bottom syntax. Gone are the days when those Legos were simple little sets. We've moved on to building Death Stars out of legos with more than 3500 pieces. Due to increasingly complex apps we've had to find new techniques to keep all those pieces together. And as we did we learned that we needed to be much more careful. We've learned to write code that is easily tested. And we've learned to write code that protects people. Visual Basic was yet another stop towards the evolution to modern design principals. We've covered others and we'll cover more in coming episodes. So until next time, think of the continuing evolution and what might be next. You don't have to be in front of it, but it does help to have a nice big think on how it can impact projects you're working on today. So thank you for tuning in to yet another episode of the History of Computing Podcast. We're so lucky to have you. Have a great day!

Join Larry for a deep dive in the Microsoft Interface Definition Language (MIDL) 3.0 for declaring Windows Runtime types. How did MIDL start and how did it get to where it is today?MIDL 3 - https://aka.ms/ifdef-midl-3C++/WinRT language projection: http://aka.ms/cppwinrtFollow Larry @ostermanFollow Nikola @metulev

In this episode of GoingNative, Steve Carroll talks to Brent Rector and Kenny Kerr from the Windows team about C++/WinRT!C++/WinRT is a standard C++ header-based library that takes WinRT APIs and exposes them as C++ classes that you can use in your application in a natural and familiar way. You can consume it from any standard C++ application and is the easiest way to get access to the modern Windows APIs. C++/WinRT is designed to offer an improved alternative to C++/CX and works with any major standard C++ compiler on Windows. It shipped inside the Windows 10 SDK v17025 for the first time. This means that as long as you have a version of the Windows 10 SDK installed that is at least 17025, you can simply include the appropriate headers from within any C++ project and start writing modern C++ code using the Windows API.You can learn more about C++/WinRT here: https://moderncpp.com/You can also check out the CppCon 2017 talk: C++/WinRT and the future of C++ on Windows

A Stowed Exception is a type of Exception made by UWP applications. It was introduced in Windows 8.0 as part of WinRT API (now known as UWP).The Exception Code is 0xC000027B.The first Exception Parameter (0) is the starting address of an array of pointers to structures that begin with a STOWED_EXCEPTION_INFORMATION_HEADER structure. Since Windows 8.1, STOWED_EXCEPTION_INFORMATION_V2 has been the version in use.The second Exception Parameter (1) is the number of pointers in the array.Stowed Exception has been replaced/enhanced by the Point-of-Failure Exception (0xC000027C). Like POF Exceptions, the Exception Code is generated by the WinRT Framework. It does not require applications to be re-compiled for it to be used.A Stowed Exception is raised when an asynchronous operation fails. When the exception is reported from the worker thread via a RoOriginateException or RoOriginateLanguageException call, a Stack Backtrace (array of Instruction Pointers) is collected of the current thread via a CaptureStackBackTrace function call. The Stack Backtrace and HRESULT of the exception is wrapped in an IRestrictedErrorInfo object and routed through the language projection layers of WinRT to the caller.If the exception is not handled by the caller, the stowed exception is thrown fatally. Because the throwing is deferred, the current context of the associated dump has little value. The thread of the original issue regularly no longer exists, and if it does, has concluded the operation (meaning the thread's stack memory has been overwritten). This means that function parameters and local variables are not available.Follow these steps when debugging these issues with the Debugging Tools for Windows:.exr -1View the Code, Stowed Exception Array Address and Count via the parameters!pde.dseLists the Stowed ExceptionsEach HRESULT is described (same output as !pde.err)Each Backtrace is displayed as a call stackEach (optionally) nested exception is displayed (e.g. !sos.pe output of a CLR Exception)Additional Resources:Inside - Point-of-Failure ExceptionInside - .exrInside - Windows SDKDefrag Tools - PDE Debugger Extension (via OneDrive link)Defrag Tools - #136 - Debugging User Mode Crash Dumps Part 2Defrag Tools - #167 - Debugging User Mode Crash Dumps ReduxMicrosoft Docs - Debugging Tools for WindowsNTDebugging Blog - Part 1 + Part 2MSDN - RoOriginateExceptionMSDN - RoOriginateLanguageExceptionMSDN - IRestrictedErrorInfo interface

A Point-of-Failure (POF) Exception is a type of Exception made by UWP applications. It was introduced in the Windows 10 Fall Creators Update (Sept. 2017).The Exception Code is 0xC000027C.The first Exception Parameter (0) is an HRESULT. In 64bit dumps, the value needs to be masked down to the bottom 32bits. e.g. 0xFFFFFFFF80070512 => 0x80070512Point-of-Failure Exception replaces/enhances Stowed Exception (0xC000027B). Like Stowed Exceptions, the Exception Code is generated by the WinRT Framework. It does not require applications to be re-compiled for it to be used.A POF Exception is raised when an asynchronous operation fails. When the exception is reported from the worker thread, a Process Shapshot is collected of the process. The PSS handle and HRESULT of the exception is wrapped in an IRestrictedErrorInfo based object and routed through the language projection layers of WinRT. If the exception is not handled by the caller, the Process Snapshot is used to report the issue back at "state" when RoOriginateException or RoOriginateLanguageException was called.Follow these steps when debugging these issues with the Debugging Tools for Windows:.exr -1Determine the HRESULT via the first parameter!error and/or !pde.err Describe the HRESULT.ecxrSet the current debugger context to the Process Snapshot positionkView the call stackAdditional Resources:Inside - Stowed ExceptionInside - .exrInside - .ecxrInside - Windows SDKDefrag Tools - PDE Debugger Extension (via OneDrive link)Microsoft Docs - Debugging Tools for WindowsMSDN - RoOriginateExceptionMSDN - RoOriginateLanguageExceptionMSDN - IRestrictedErrorInfo interface

Rob and Jason are joined by Kenny Kerr from Microsoft to discuss the C++/WinRT library, previously known as ModernCpp, a standard C++ projection for the Windows Runtime. Kenny Kerr is an engineer on the Windows team at Microsoft, an MSDN Magazine contributing editor, Pluralsight author, and creator of moderncpp.com (C++/WinRT). He writes at kennykerr.ca and you can find him on Twitter at @kennykerr. News VOTE! Support debugging of C++ code with IntelliTrace All CppCon 2016 Videos Are Up! Visual Studio "15" Preview 5 Now Available Compiler Tools Layout in Visual Studio "15" C++ 14/17 Features and STL Fixes in VS "15" Preview 5 Bring your C++ codebase to Visual Studio with "Open Folder" C++ compiler diagnostics improvements in VS "15" Preview 5 C++ IntelliSense Improvements - Predictive IntelliSense & Filtering CMake support in Visual Studio Visual C++ Compiler Version Faster C++ solution load with VS "15" C++ Core Check code analysis is included with VS "15" Kenny Kerr @kennykerr Kenny Kerr's Blog Links CppCon 2016: WG21-SG14 - Making C++ better for games, embedded and financial developers Creative Assembly Sponsor C++/WinRT Available on GitHub cppwinrt repository on GitHub CppCon 2016: Kenny Kerr & James McNellis "Embracing Standard C++ for the Windows Runtime" CppCon 2016: Kenny Kerr & James McNellis "Putting Coroutines to Work with the Windows Runtime"  

En este programa nos acompaña Pablo Carballude que, además de ser paisano mío, es Technical Evangelist en Microsoft. Pablo aceptó muy amablemente nuestra invitación para participar en el podcast y hablarnos sobre la plataforma de desarrollo para Windows Phone 8. Con él repasamos un poco la historia de esta plataforma y los cambios que ha [...]

Carl and Richard talk to Brian Noyes about Microsoft's Patterns and Practices Kona Guidance for developing Windows Store Line of Business Apps. The conversation digs into the evolution of 'Prism for WinRT' into Kona and how they are substantially different because Windows Stores are substantially different. Brian digs into specifics about Windows Store apps, like Suspend, Terminate and Resume and its impact on guidance. If you're interested in Windows 8 development, check out The Tablet Show, especially the shows in the links below!Support this podcast at — https://redcircle.com/net-rocks/donations

Carl and Richard talk to Rocky Lhotka about his experiences building Windows 8 tablet applications for the enterprise. The conversation starts out with a broader discussion around all of the different tablets in the enterprise, the challenge of managing them as well as developing for them. Rocky then digs into the deployment story for Windows 8 Store applications - including putting your apps into the store as well as side loading. Side loading is where things get complicated, as Rocky describes it, it depends on what version of Windows 8 you're using, and what licensing agreements your organization has with Microsoft as to what the costs and configurations are for deploying apps. Rocky has done the hard research here!

Learn all about the new component extensions to C++, that help target the Windows Runtime Library. Learn when to use WRL directly and when to use the components extension. This talk is for you if you want to understand all the nitty-gritties of the language, semantics and best practices when creating your own WinRT component for reuse in your Windows Store Apps.

We are currently experience an exciting shift for JavaScript developers. For the first time, the Node.js and WinRT platforms along with modern browsers enable developers to write end-to-end applications in a single language that run on virtually any device. In this talk you will learn the fundamentals of building rich client side apps that utilize powerful server APIs all written in JavaScript. .

Project Austin is a show-case for C++ apps, and has caught fire in the press. It really captures the essence of the power of writing Windows 8 Apps in C++. The Visual C++ team leveraged DirectX, C++ AMP, PPL and WinRT to take advantage of the Windows 8 hardware (including stylus). Come and dive into the Austin codebase as we share tips and tricks we discovered along the way.

Carl and Richard talk to Lino Tadros about his work building tablet applications. Lino compares and contrasts the experiences of building iOS, Android and WinRT applications.

Спекулятивный подкаст про то, что ждет нас с приходом WinRT, Win8 и Surface

Rx 2.0 is RTW! Get it here.I caught up with Bart at his whiteboard (of course) to discuss the significance of this release as well address some of the great additions to Rx as outlined below (many of the topics below have been discussed in depth in other Rx interviews with Bart.) We also talk about the new experimental build shipping model. Much of the time is spent talking about the portable libraries architecture for Rx for Windows 8, .NET 4.5, WP7/7.5 and beyond. Bart has been very, very busy and as usual his engineering is golden.Tune in! It's always a pleasure to geek out with Bart. So much to learn. Congratulations to the Rx team!!!The highlights of Rx 2.0 include:Support for building Windows Store apps for Windows 8. This includes primitives to synchronize with the Windows XAML CoreDispatcher and interop with WinRT events and IAsync* objects. Support for Portable Class Library projects, allowing code reuse across ".NET Framework 4.5" and ".NET Framework 4.5 for Windows Store apps" projects. We're planning on adding Windows Phone 8 support to this going forward. Integration with the new C# 5.0 and VB 11 "async" and "await" features. In Rx v2.0, you can await an observable sequence, allowing one to apply the power of Rx to the new asynchronous programming model. Enormous performance improvements, with a 4x speedup of the query pipeline, vastly reduced object allocation rates, massively increased throughput of schedulers, and much more. An improved error handling strategy, enabling higher resiliency and proper resource cleanup for queries in the face of user errors at various levels. Thorough revisit of the way we deal with time, to improve efficiency and predictability. This includes better support for periodic timers, improvements to absolute time scheduling, etc. Various new and improved query operators.

While at PWOP Studios in New London, Carl and Richard sat down and chatted with each other about the leak of the Windows Phone 8 SDK. No one is certain if the SDK is final, but it must be close. The boys dig into the key points of what was found in the SDK - some new features not found in WinRT for Windows 8 (but perhaps coming in later versions), how the programming models shake out, and the requirements for the development platform. The conversation also digs into how 100,000 Windows Phone 7 apps are going to be moved to Windows Phone 8. Crazy times!

Abstract: Join Tim Huckaby Founder/Chairman, InterKnowlogy Founder/CEO, Actus Interactive Software and Rockford Lhotka CTO, Magenic discuss .Net 4.5 and Windows 8 new Metro WinRT. Rocky talks about .NET new features VB, C#, async await keywords and the task enhancement library that his is excited about. He also shares insights into working with CSLA.NET to work with WinRT. This interview is full of information!Learn how to make your Windows 8 app idea come to life in 30 days!About RockfordRockford Lhotka is the creator of the popular CSLA .NET development framework, and is the author of numerous books, including Expert 2008 Business Objects. He is a Microsoft Regional Director and MVP, and a regular presenter at major conferences around the world. Rockford is the Principal Technology Evangelist for Magenic, a company that specializes in planning, designing, building and maintaining your enterprise's most mission critical systems. For more information go to www.lhotka.net.About TimTim Huckaby is focused on the Natural User Interface (NUI) in Rich Client and Rich Internet Application (RIA) Technologies like Silverlight & WPF on the computer, the Surface, and Windows Phone 7. He has been called a "Pioneer of the Smart Client Revolution" by the press.Tim has been awarded multiple times for the highest rated Keynote and technical presentations for Microsoft and numerous other technology conferences around the world by Microsoft Corporation. Tim has done presentations on Microsoft technologies at technology events like Microsoft Tech Ed, Product Launch events, Dev Days, MEC, World Wide Partner Conference, MGB, MGX, and the PDC, along with 3rd party technology conferences all over the world is consistently rated in the top 10% of all speakers at these events. Tim was selected by Microsoft as a speaker for the International .NET Association and speaks at events world-wide on Microsoft's behalf. Tim has done keynote demos at big Microsoft events and product launches for numerous Microsoft executives including Bill Gates and Steve Ballmer.Tim founded InterKnowlogy, experts in Microsoft .NET and Microsoft Platforms, and Actus Interactive Software, and has 25+ years experience including serving on a Microsoft product team as a development lead on an architecture team. Tim is a Microsoft Regional Director, an MVP and serves on multiple Microsoft councils and boards like the Microsoft .NET Partner Advisory Council.Resources we recommend you check outMagenic website Rocky's blog CSLA .NET Tim Huckaby's blog Follow Tim on Twitter Get started with Windows 8 Development - Download Visual Studio Win8 Express

Scott's confused about what 'WinRT' is. Is it a new .NET? A new runtime? Is .NET dead? He's totally confused so he talks to Immo Landwerth who sets him straight with complete context from Win32 to COM to .NET and beyond.

Bart De Smet is back and he's going to go deep into improvements made to Rx 2.0 RC (so, Rx 2.0 getting close to coming out of the oven!). As you'd expect, Bart and company have been very busy since Rx 2.0 Beta - lots of performance and reliability improvements and some heavy work in how Rx manages time, new error handling capabilities and event subscription improvements for Rx running on WinRT.Most of the time is spent at the whiteboard - very comfortable and natural place for Bart! Note: there is a lot of time in this interview, both in terms of interview length and the notion of time itself. Use at your own risk and watch out for unexpected wormholes.More on Rx 2.0 RC:This new release of Rx includes a number of improvements to the way we deal with time. As you likely know, dealing with time is a complex undertaking in general, especially when computers are involved. Rx has a lot of temporal query operators to perform event processing, and therefore it needs to be able to schedule work to happen at particular times. As a result, notions of time exist in virtually any layer of the system: from the schedulers at the bottom (in System.Reactive.Core) to the query operators at the top (in System.Reactive.Linq). [Bart De Smet]Download page: https://go.microsoft.com/fwlink/?LinkID=255295 Bart's epic blog post: https://blogs.msdn.com/b/rxteam/archive/2012/06/17/reactive-extensions-v2-0-release-candidate-available-now.aspx

Carl Franklin steps up to the plate to be the guest on this episode of The Tablet Show, talking about what's new in the Consumer Preview of Windows 8 for developers. WinRT has made a big jump from the Developer Preview to the Consumer Preview, and it takes a rethink to your application design. Carl goes through the changes the .NET folks will care about, like how reflection and system.io has changed. Check out the links for tons of resources to get going with WinRT on the Consumer Preview!

Carl and Richard talk to Kate Gregory about C++ in Windows 8. Kate talks about how the combination of C++11 and WinRT brings C++ developers to the forefront of development in Windows 8. The latest version of C++ brings lambdas, async and auto var behavior to the language, making complex development far more manageable. The playing field is really levelled in WinRT between HTML 5, C++ and C#!

Andy and Phil talk HTML5 & WinRT. This is a content summary only. Visit our site for full content, links, images, and more.

Carl and Richard talk to Brian Noyes about Microsoft's Patterns and Practices Kona Guidance for developing Windows Store Line of Business Apps. The conversation digs into the evolution of 'Prism for WinRT' into Kona and how they are substantially different because Windows Stores are substantially different. Brian digs into specifics about Windows Store apps, like Suspend, Terminate and Resume and its impact on guidance. If you're interested in Windows 8 development, check out The Tablet Show, especially the shows in the links below!Support this podcast at — https://redcircle.com/net-rocks/donations

Carl and Richard talk to Jeremy Likness about Silverlight 5. Is Silverlight dead? Not by a long shot. Jeremy talks about the great work going on the Silverlight today and how it still is the most efficient way to build applications that run on both Windows and OSX. The conversation drills into the new features of Silverlight 5 and dispels a lot of the myths around the future of Silverlight. Jeremy also talks about Jounce, his MVVM+MEF framework on Codeplex and the relationship between Silverlight and WinRT.Support this podcast at — https://redcircle.com/net-rocks/donations

Where is Windows 8 taking us? While at DevConnections, Carl and Richard participated in a panel discussion with Tim Huckaby, Billy Hollis, Dr. Neil Roodyn and Paul Sheriff about the new Windows Runtime. Also listen for a brief appearance of the one-and-only Mark Minasi.Support this podcast at — https://redcircle.com/net-rocks/donations

Carl and Richard talk to Dan Hanan and Danny Warren about mixing Kinect together with WinRT. Back at the Build conference keynote a 'marketecture' diagram showed how existing applications still work in Windows 8 but also introduced a new platform using WinRT. At the time attendees were told that the blue side (existing applications) and the green side (WinRT) will never cross. Then the folks at Interknowlogy got to work. Dan and Danny talk about how they built an application utilizing Kinect, depending on an SDK that runs on the blue side to communicate with a Metro application that runs on the green side. Crossing the streams? You bet!Support this podcast at — https://redcircle.com/net-rocks/donations

Introducing episode one of The Tablet Show, a new weekly .NET Rocks! spinoff primarily for .NET developers but focused on Tablet development (WinRT/Metro, iOS and Android). For the inaugural show, Carl and Richard talk to Rocky Lhotka and Billy Hollis about their assessments of Windows 8, WinRT and the Metro UI. After discussing what WinRT is, the discussion dives into the real challenges of migrating applications to Metro. Rocky talks about migrating the CSLA Silverlight edition to Metro. The conversation then moves into some of the new services of WinRT, including sharing and search.Support this podcast at — https://redcircle.com/net-rocks/donations