| Building Tab Experiences for Microsoft Teams | Scott Peterson | 00:52:01 | Microsoft Teams | 
                            
                                | Building Bot Experiences for Microsoft Teams | Scott Peterson | 01:06:04 | Microsoft Teams | 
                            
                                | Unit Testing with PyTest | Eric Greene | 01:36:05 | Python, Testing | 
                            
                                | Microsoft Teams Development Fundamentals | Scott Peterson | 00:45:48 | Microsoft Teams | 
                            
                                | Multithreading in Python | Eric Greene | 01:38:54 | Python, Multithreading | 
                            
                                | Asynchronous Programming in Python | Eric Greene | 01:11:34 | Python | 
                            
                                | Getting Started with Azure Cloud Development | Eric Greene | 00:58:47 | Azure, GitHub | 
                            
                                | Configure and Deploy a Web App with Azure App Services and GitHub | Eric Greene | 01:17:07 | Azure, GitHub | 
                            
                                | Reusable Components and Publishing in Blazor | Eric Greene | 01:11:47 | Blazor | 
                            
                                | Building Components with Blazor | Eric Greene | 00:48:12 | Blazor | 
                            
                                | Getting Started with Blazor | Eric Greene | 01:27:47 | Blazor | 
                            
                                | New Features in C# 9.0 | Eric Greene | 01:15:41 | C# | 
                            
                                | CI/CD with Azure Pipelines and Artifacts, Part 2 | Eric Greene | 01:03:40 | Azure, Azure DevOps | 
                            
                                | CI/CD with Azure Pipelines and Artifacts, Part 3 | Eric Greene | 00:57:58 | Azure, Azure DevOps | 
                            
                                | CI/CD with Azure Pipelines and Artifacts, Part 1 | Eric Greene | 01:21:48 | Azure, Azure DevOps | 
                            
                                | Assessing an Azure App Migration | Blaize Stewart | 01:02:38 | Azure | 
                            
                                | Anonymization and Pseudonymization for Data Professionals | Zacharias Voulgaris | 01:08:03 | Cybersecurity | 
                            
                                | Getting Started with Azure App Migrations | Blaize Stewart | 00:41:54 | Azure | 
                            
                                | Getting Started with Kubernetes | Blaize Stewart | 00:54:36 | Kubernetes | 
                            
                                | Compression and Archiving in Python | Eric Greene | 01:04:53 | Python | 
                            
                                | Deployment in .NET 5.0 | Ron Sumida | 01:22:13 | .NET | 
                            
                                | Privacy Fundamentals | Zacharias Voulgaris | 01:14:47 | Privacy, Cybersecurity | 
                            
                                | Common File Formats in Python | Eric Greene | 00:58:07 | Python | 
                            
                                | The File System in Python, Part 1 | Eric Greene | 01:13:39 | Python | 
                            
                                | The File System in Python, Part 2 | Eric Greene | 01:03:57 | Python | 
                            
                                | Introduction to .NET 5.0 | Ron Sumida | 01:19:16 | .NET | 
                            
                                | Dictionaries in Python | Eric Greene | 01:01:43 | Python | 
                            
                                | Object-Oriented Programming in Python, Part 1 | Eric Greene | 01:32:35 | Python | 
                            
                                | Object-Oriented Programming in Python, Part 2 | Eric Greene | 01:40:57 | Python | 
                            
                                | Fundamentals of Deep Learning | Jeff Prosise | 01:09:15 | Neural Networks, Deep Learning, Keras, Machine Learning, TensorFlow | 
                            
                                | Cybersecurity Fundamentals, Part 4: Complex Systems | Zacharias Voulgaris | 00:05:02 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 5: Cryptography | Zacharias Voulgaris | 00:16:03 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 6: Cryptanalysis and Cyber Attacks | Zacharias Voulgaris | 00:16:41 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 7: Steganography | Zacharias Voulgaris | 00:09:14 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 8: Network Security | Zacharias Voulgaris | 00:11:41 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 9: Applications and Policies | Zacharias Voulgaris | 00:12:43 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 10: Software Resources | Zacharias Voulgaris | 00:04:51 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 11: Summary | Zacharias Voulgaris | 00:05:49 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 1: Overview | Zacharias Voulgaris | 00:04:15 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 2: Rationale | Zacharias Voulgaris | 00:03:08 | Cybersecurity, Security | 
                            
                                | Cybersecurity Fundamentals, Part 3: Randomness | Zacharias Voulgaris | 00:05:56 | Cybersecurity, Security | 
                            
                                | Unit Testing in Python | Eric Greene | 01:33:19 | Python, Azure DevOps | 
                            
                                | Principal Component Analysis | Jeff Prosise | 00:33:03 | Machine Learning | 
                            
                                | Functions in Python, Part 2 | Eric Greene | 01:09:55 | Python | 
                            
                                | Functions in Python, Part 1 | Eric Greene | 01:19:47 | Python | 
                            
                                | Managing Application State with NgRx, Part 1 | Eric Greene | 00:56:22 | Angular, NgRx | 
                            
                                | Managing Application State with NgRx, Part 2 | Eric Greene | 01:22:49 | Angular, NgRx | 
                            
                                | Managing Application State with NGXS, Part 1 | Eric Greene | 00:59:01 | Angular, NGXS | 
                            
                                | Managing Application State with NGXS, Part 2 | Eric Greene | 01:25:34 | Angular, NGXS | 
                            
                                | Libraries in Angular | Eric Greene | 01:14:21 | Angular | 
                            
                                | Lazy Loading in Angular | Eric Greene | 01:23:19 | Angular | 
                            
                                | Getting Started with Vue.js | Eric Greene | 00:58:24 | Vue.js, JavaScript | 
                            
                                | Advanced Hooks in React | Eric Greene | 01:31:19 | React | 
                            
                                | Optimizing React Performance with React Profiler | Eric Greene | 01:26:21 | React, React Profiler, Performance | 
                            
                                | Managing State with MobX, Part 3 | Eric Greene | 01:24:29 | React, MobX | 
                            
                                | Managing State with MobX, Part 2 | Eric Greene | 01:20:22 | React, MobX | 
                            
                                | Managing State with MobX, Part 1 | Eric Greene | 01:44:40 | React, MobX | 
                            
                                | React Router, Part 3 | Eric Greene | 01:11:45 | React, React Router | 
                            
                                | React Router, Part 2 | Eric Greene | 01:06:03 | React, React Router | 
                            
                                | React Router, Part 1 | Eric Greene | 01:36:39 | React, React Router | 
                            
                                | Authorization in Angular | Eric Greene | 01:04:54 | Angular | 
                            
                                | Form Validation and Error Handling in Angular | Eric Greene | 01:28:52 | Angular | 
                            
                                | User Authentication in Angular | Eric Greene | 01:57:03 | Angular | 
                            
                                | Routing and Layout in Angular | Eric Greene | 01:00:28 | Angular | 
                            
                                | Getting Started with Angular 11 | Eric Greene | 01:10:28 | Angular | 
                            
                                | Preparing for .NET 5 | Ron Sumida | 01:12:43 | .NET, .NET Core | 
                            
                                | Fusing Power Apps with Power BI Reports | Scott Peterson | 01:00:56 | Power Apps, Power Platform, Power BI | 
                            
                                | Building Business-Ready Power Apps | Scott Peterson | 00:59:10 | Power Apps, Power Platform, Accessibility | 
                            
                                | Extending Power Apps with Automation | Scott Peterson | 01:00:34 | Power Apps, Power Automate, Power Platform | 
                            
                                | Getting Started with Microsoft Power Apps | Scott Peterson | 00:57:34 | Power Apps, Power Platform | 
                            
                                | Fundamentals of ML.NET | Jeff Prosise | 01:30:50 | Machine Learning, .NET Core, ML.NET | 
                            
                                | Fundamentals of Machine Learning | Jeff Prosise | 01:56:44 | Python, Machine Learning, scikit-learn | 
                            
                                | Managing Azure DevOps Build Pipelines | Eric Greene | 00:40:36 | Azure, Azure DevOps | 
                            
                                | Managing Azure DevOps Repositories | Eric Greene | 01:55:09 | Azure, Azure DevOps | 
                            
                                | Managing Azure DevOps Project Users | Eric Greene | 01:04:15 | PowerShell Core, Azure DevOps, Azure Active Directory | 
                            
                                | Connecting PowerShell Core to Azure and Azure DevOps | Eric Greene | 01:03:18 | PowerShell Core, Azure DevOps, Azure | 
                            
                                | Managing Azure DevOps Projects | Eric Greene | 00:58:02 | PowerShell Core, Azure DevOps | 
                            
                                | Getting Started with PowerShell Core, Part 3 | Eric Greene | 01:14:23 | PowerShell Core | 
                            
                                | Getting Started with PowerShell Core, Part 2 | Eric Greene | 00:55:44 | PowerShell Core | 
                            
                                | Getting Started with PowerShell Core, Part 1 | Eric Greene | 01:01:24 | PowerShell Core, Azure DevOps | 
                            
                                | Supercharging Power BI Reports | Scott Peterson | 01:05:13 | Power BI, Power BI Desktop | 
                            
                                | CI and CD for Azure Functions in Azure DevOps | Eric Greene | 01:23:23 | Azure, Azure DevOps, Azure Functions | 
                            
                                | CI and CD for Containers in Azure DevOps | Eric Greene | 01:19:29 | Azure, DevOps, Azure DevOps | 
                            
                                | CI and CD in Azure DevOps | Eric Greene | 00:48:49 | Azure, DevOps, Azure DevOps | 
                            
                                | Getting Started with Azure DevOps | Eric Greene | 01:09:58 | Azure, DevOps, Azure DevOps | 
                            
                                | Getting Started with Gatsby, Part 1 | Eric Greene | 00:55:19 | React, Gatsby | 
                            
                                | Getting Started with Gatsby, Part 2 | Eric Greene | 01:06:17 | React, Gatsby | 
                            
                                | Getting Started with Next.js, Part 2 | Eric Greene | 01:18:44 | React, Next.js | 
                            
                                | Components and Data with React, ASP.NET Core, and EF Core | Eric Greene | 01:11:04 | React, ASP.NET Core, Entity Framework Core | 
                            
                                | Getting Started with Next.js, Part 1 | Eric Greene | 01:09:54 | React, Next.js | 
                            
                                | Collecting and Saving Data with React, ASP.NET Core, and EF Core | Eric Greene | 01:11:25 | React, ASP.NET Core, Entity Framework Core | 
                            
                                | Introduction to Keras | Mark Tabladillo | 01:01:22 | Neural Networks, Deep Learning, Keras | 
                            
                                | Integrating Entity Framework Core with React and ASP.NET Core | Eric Greene | 01:19:29 | React, ASP.NET Core, Entity Framework Core, Axios | 
                            
                                | Integrating React and ASP.NET Core | Eric Greene | 00:46:37 | React, ASP.NET Core | 
                            
                                | Building a Single-Page Application with React 16 and ASP.NET Core 2.2 | Eric Greene | 01:31:31 | React, ASP.NET Core | 
                            
                                | Introduction to Blazor | Jeff Fritz | 00:49:34 | Blazor | 
                            
                                | Building RESTful Web APIs with ASP.NET Core and Azure | Scott Peterson | 00:56:10 | Swashbuckle, Swagger, ASP.NET Core, OpenAPI, Azure | 
                            
                                | OpenAPI for ASP.NET Core 2.2 | Jeff Fritz | 00:44:33 | OpenAPI, ASP.NET Core | 
                            
                                | Serverless Computing with Azure Functions | Scott Peterson | 00:54:33 | Azure Functions, Serverless, Azure | 
                            
                                | What's New and Improved in Visual Studio 2019 | Scott Peterson | 00:50:09 | Visual Studio | 
                            
                                | Selective Updating in React | Eric Greene | 01:10:42 | React | 
                            
                                | Using Context in React | Eric Greene | 01:08:11 | React | 
                            
                                | Advanced Azure Integration with AKS | Blaize Stewart | 00:49:12 | Azure Kubernetes Service, Azure, AKS, Kubernetes | 
                            
                                | Using Refs in React | Eric Greene | 00:53:12 | React | 
                            
                                | React Reducer Hooks | Eric Greene | 01:11:46 | React | 
                            
                                | Styled Components in React, Part 1 | Eric Greene | 01:05:03 | CSS, React | 
                            
                                | Getting Started with Azure Kubernetes Service | Blaize Stewart | 00:54:04 | Azure, AKS, Kubernetes, Azure Kubernetes Service | 
                            
                                | Mastering Cosmos DB with the SQL API | Scott Peterson | 01:14:39 | Azure, Cosmos DB | 
                            
                                | What's New in ASP.NET Core 2.2 | Jeff Fritz | 00:36:17 | ASP.NET Core | 
                            
                                | Docker for ASP.NET Core Developers | Jeff Fritz | 00:50:54 | .NET Core, ASP.NET Core, Docker | 
                            
                                | React State Hooks | Eric Greene | 01:13:04 | React | 
                            
                                | Fundamentals of GitHub: Collaboration and Social Coding | Jeff Fritz | 00:51:51 | GitHub, Git | 
                            
                                | Fundamentals of SQL Server Reporting Services (SSRS) | Ike Ellis | 00:56:46 | SQL Server, SSRS | 
                            
                                | Fundamentals of SQL Server Integration Services (SSIS) | Ike Ellis | 01:00:14 | SQL Server, SSIS | 
                            
                                | Fundamentals of Git: Using Git for Source Control | Jeff Fritz | 01:09:12 | Git | 
                            
                                | More CSS Selectors for React Developers | Eric Greene | 01:16:44 | CSS, React | 
                            
                                | Getting Started with CSS for React Developers | Eric Greene | 01:35:09 | CSS, React | 
                            
                                | CSS Selectors for React Developers | Eric Greene | 00:50:04 | CSS, React | 
                            
                                | Essentials of CSS for React Developers | Eric Greene | 00:54:25 | CSS, React | 
                            
                                | Apollo Client State with React | Eric Greene | 02:07:05 | JavaScript, Apollo, React, GraphQL | 
                            
                                | Higher-Order Components with React | Eric Greene | 01:18:37 | Apollo, React, GraphQL, JavaScript | 
                            
                                | GraphQL Subscriptions with React | Eric Greene | 01:01:04 | React, JavaScript, Apollo, GraphQL | 
                            
                                | Performing GraphQL Mutations with Apollo | Eric Greene | 01:07:53 | JavaScript, Apollo, GraphQL | 
                            
                                | Using GraphQL with the React Apollo Client | Eric Greene | 01:00:55 | JavaScript, Apollo, React, GraphQL | 
                            
                                | Getting Started with Apollo and GraphQL | Eric Greene | 01:04:34 | Apollo, GraphQL, JavaScript | 
                            
                                | Getting Started with RxJS | Eric Greene | 01:00:59 | RxJS | 
                            
                                | RxJS Operators | Eric Greene | 00:59:24 | RxJS | 
                            
                                | Managing Redux Side Effects with Thunk | Eric Greene | 01:50:37 | Redux, Thunk | 
                            
                                | Object-Oriented Programming in Scala | Julian Templeman | 01:08:35 | Scala | 
                            
                                | Scala Basics | Julian Templeman | 01:05:05 | Scala | 
                            
                                | Using Inheritance in Scala | Julian Templeman | 00:57:38 | Scala | 
                            
                                | Introduction to Scala | Julian Templeman | 00:19:04 | Scala | 
                            
                                | Getting Started with Angular and ASP.NET Core | Jeff Fritz | 01:11:04 | .NET Core, ASP.NET Core, Angular | 
                            
                                | Classification with Support Vector Machines | Eric Greene | 01:01:39 | Python, scikit-learn, Support Vector Machines, Machine Learning | 
                            
                                | Linear Regression in Python | Eric Greene | 01:19:37 | scikit-learn, Machine Learning, Python | 
                            
                                | Redux with React | Eric Greene | 01:14:55 | Redux, React | 
                            
                                | Identity Enhancements in ASP.NET Core 2.1 | Jeff Fritz | 00:44:54 | ASP.NET Core | 
                            
                                | Live Web Interactions with ASP.NET Core and SignalR | Jeff Fritz | 00:58:24 | SignalR, Azure, ASP.NET Core | 
                            
                                | Getting Started with Redux | Eric Greene | 01:46:35 | Redux | 
                            
                                | React Class Components | Eric Greene | 01:10:03 | React | 
                            
                                | Building Razor Pages with ASP.NET Core | Jeff Fritz | 00:32:35 | Razor, ASP.NET Core | 
                            
                                | Getting Started with ASP.NET Core | Jeff Fritz | 00:55:17 | .NET Core, ASP.NET Core | 
                            
                                | .NET Standard for Mere Mortals | Jeff Fritz | 00:47:51 | .NET | 
                            
                                | Blockchain on Azure | Blaize Stewart | 01:07:51 | Azure, Blockchain | 
                            
                                | Introduction to React | Eric Greene | 01:35:55 | React, JavaScript, Web | 
                            
                                | Azure Infrastructure-as-a-Service | Dave Franklyn | 01:05:24 | IaaS, Azure | 
                            
                                | Introduction to Azure Infrastructure | Dave Franklyn | 00:21:05 | Azure | 
                            
                                | Advanced Topics in Software Development with Blockchains, Ethereum, and Solidity | Blaize Stewart | 01:03:33 | Blockchain, Ethereum, Solidity | 
                            
                                | Developing Smart Contracts on Ethereum with Solidity | Blaize Stewart | 01:35:21 | Blockchain, Solidity, Ethereum | 
                            
                                | Introduction to Blockchain | Blaize Stewart | 00:52:21 | Blockchain | 
                            
                                | Getting Started with Azure IoT | Scott Peterson | 01:00:59 | Azure, IoT | 
                            
                                | Comprehensions in Python | Eric Greene | 00:52:11 | Python | 
                            
                                | Operator Overloading in Python | Eric Greene | 00:53:57 | Python | 
                            
                                | Working with Data using Pandas | Eric Greene | 00:56:15 | Data Science, Python, Pandas | 
                            
                                | Statistics with Python, Part 3 | Eric Greene | 01:16:47 | Matplotlib, SciPy, Python, NumPy, Data Science, Pandas | 
                            
                                | Getting Started with MobX | Eric Greene | 01:09:49 | MobX, React | 
                            
                                | Getting Started with Perl 5 | Eric Greene | 01:31:00 | Perl | 
                            
                                | Introduction to Deep Learning | Mark Tabladillo | 01:11:16 | Neural Networks, Deep Learning | 
                            
                                | Best Practices for Azure Deployment | Ken Muse | 00:45:25 | Azure | 
                            
                                | Building Neural Networks with TensorFlow | Mark Tabladillo | 00:57:50 | TensorFlow, Neural Networks, Deep Learning | 
                            
                                | Building Neural Networks with MXNet | Mark Tabladillo | 01:12:14 | Neural Networks, MXNet, Deep Learning | 
                            
                                | Statistics with Python, Part 2 | Eric Greene | 01:04:33 | Data Science, SciPy, NumPy, Python | 
                            
                                | Getting Started with Data Science using Python | Eric Greene | 00:48:32 | Data Science, Python | 
                            
                                | Statistics with Python, Part 1 | Eric Greene | 01:06:24 | Data Science, NumPy, Python | 
                            
                                | Functional Programming in C++ | Julian Templeman | 00:48:09 | C++, Functional Programming | 
                            
                                | Programming Concurrency in C++ | Julian Templeman | 00:52:45 | C++, Multithreading | 
                            
                                | Using HBase | Frank La Vigne | 00:50:35 | Data Science, HBase, Hadoop, Big Data | 
                            
                                | Mastering .NET Core: Introduction | Ron Sumida | 01:06:12 | .NET Core | 
                            
                                | Microsoft Cognitive Services: Entity Linking Intelligence Service | Scott Peterson | 00:40:36 | Cognitive Services | 
                            
                                | Using Pig with Hadoop | Frank La Vigne | 00:50:13 | Data Science, Pig, Hadoop, Big Data | 
                            
                                | Preparing Raw Data for Big Data and Data Science | Eric Greene | 02:02:08 | Data Science, Azure, SQL, Big Data | 
                            
                                | Querying for Data | Eric Greene | 00:53:18 | Data Science, SQL, Big Data | 
                            
                                | Using Hive to Query Hadoop | Frank La Vigne | 00:57:31 | Data Science, Azure, Hadoop, Big Data, Hive | 
                            
                                | Introducing Hadoop | Frank La Vigne | 00:23:27 | Data Science, Hadoop, Azure, Big Data | 
                            
                                | Processing Big Data with MapReduce | Frank La Vigne | 01:07:23 | Data Science, Azure, Hadoop, Big Data | 
                            
                                | Architecting Distributed Cloud Applications, Part 4: Versioning Services | Jeffrey Richter | 00:33:33 | Cloud Computing, Azure, Architecture | 
                            
                                | Architecting Distributed Cloud Applications, Part 5: Leader Election | Jeffrey Richter | 00:13:12 | Cloud Computing, Azure, Architecture | 
                            
                                | Architecting Distributed Cloud Applications, Part 6: Data Storage | Jeffrey Richter | 02:03:16 | Cloud Computing, Azure, Architecture | 
                            
                                | Architecting Distributed Cloud Applications, Part 1: Fundamentals | Jeffrey Richter | 01:45:11 | Azure, Cloud Computing, Architecture | 
                            
                                | Architecting Distributed Cloud Applications, Part 2: Networking Communication | Jeffrey Richter | 01:18:46 | Azure, Cloud Computing, Architecture | 
                            
                                | Architecting Distributed Cloud Applications, Part 3: Messaging | Jeffrey Richter | 00:31:11 | Azure, Cloud Computing, Architecture | 
                            
                                | Microsoft Cognitive Services: Project Wollongong | Scott Peterson | 00:43:27 | Microsoft Cognitive Services | 
                            
                                | Getting Started with SQL | Eric Greene | 01:03:25 | Data Science, SQL, Big Data | 
                            
                                | Working with the Relational Data Model | Eric Greene | 00:53:05 | Data Science, SQL, Big Data | 
                            
                                | Microsoft Cognitive Services: Project Cuzco | Scott Peterson | 00:44:40 | Microsoft Cognitive Services | 
                            
                                | Variables, Classes, Types, and Control Flow in Python | Eric Greene | 01:10:31 | Python | 
                            
                                | Sequences in Python | Eric Greene | 00:51:08 | Python | 
                            
                                | Modules and Packages in Python | Eric Greene | 00:38:04 | Python | 
                            
                                | Getting Started with Python | Eric Greene | 01:16:08 | Python | 
                            
                                | C++ Templates | Julian Templeman | 00:27:52 | C++, Templates | 
                            
                                | C++ Generics | Julian Templeman | 00:29:20 | C++, Generics | 
                            
                                | R-value References and Move Semantics in C++ | Julian Templeman | 00:21:16 | C++ | 
                            
                                | Constexpr, Traits, and Static Assertions in C++ | Julian Templeman | 00:29:31 | C++ | 
                            
                                | Building Neural Networks with CNTK Using a Data Science Virtual Machine | Mark Tabladillo | 01:11:51 | Cognitive Toolkit, Neural Networks, Deep Learning, CNTK | 
                            
                                | Building Neural Networks with CNTK Using Apache Spark and Azure HDInsight | Mark Tabladillo | 00:41:56 | Cognitive Toolkit, Neural Networks, Deep Learning, CNTK | 
                            
                                | Microsoft Cognitive Services: Custom Vision Service | Scott Peterson | 00:59:07 | Cognitive Services, Neural Networks | 
                            
                                | Microsoft Cognitive Services: Video Indexer | Scott Peterson | 00:53:00 | Cognitive Services | 
                            
                                | Getting Started with TypeScript | Eric Greene | 01:04:06 | TypeScript | 
                            
                                | Mastering Angular, Part 9: Consuming REST Services | Eric Greene | 01:18:32 | JavaScript, Angular | 
                            
                                | Closures in JavaScript | Eric Greene | 01:11:22 | JavaScript | 
                            
                                | Data Science for Developers | Frank La Vigne | 00:34:11 | Data Science, Artifical Intelligence, Machine Learning, Big Data | 
                            
                                | Microsoft Cognitive Services: Translation APIs | Scott Peterson | 00:52:58 | Cognitive Services | 
                            
                                | Asynchronous Programming in JavaScript | Eric Greene | 01:18:35 | JavaScript | 
                            
                                | Clustering with Spark ML | Mark Tabladillo | 01:10:03 | Data Science, Spark, Azure, Machine Learning, Big Data | 
                            
                                | Recommendation with Spark ML | Mark Tabladillo | 00:59:49 | Data Science, Spark, Azure, Machine Learning, Big Data | 
                            
                                | Promises in JavaScript | Eric Greene | 01:08:39 | JavaScript | 
                            
                                | Text Analytics with Spark ML | Mark Tabladillo | 01:05:57 | Data Science, Spark, Azure, Machine Learning, Big Data | 
                            
                                | Regression with Spark ML | Mark Tabladillo | 01:06:39 | Data Science, Spark, Azure, Machine Learning, Big Data | 
                            
                                | Classification with Spark ML | Mark Tabladillo | 01:24:13 | Data Science, Spark, Azure, Machine Learning, Big Data | 
                            
                                | Getting Started with Synaptic | Eric Greene | 01:27:24 | Data Science, Artifical Intelligence, Neural Networks, JavaScript | 
                            
                                | Symbols, Generators, and Iterators in JavaScript | Eric Greene | 00:54:59 | JavaScript | 
                            
                                | Introduction to Spark | Mark Tabladillo | 00:58:49 | Data Science, Spark, Azure, Big Data | 
                            
                                | Business Intelligence Tools and Spark | Mark Tabladillo | 01:02:01 | Data Science, Spark, Azure, Big Data | 
                            
                                | Data Processing with Spark 2 | Mark Tabladillo | 00:48:21 | Data Science, Spark, Azure, Big Data | 
                            
                                | JavaScript: The Future | Eric Greene | 01:15:32 | JavaScript | 
                            
                                | Modules in JavaScript | Eric Greene | 01:16:32 | JavaScript | 
                            
                                | Arrays in JavaScript, Part 1 | Eric Greene | 01:18:11 | JavaScript | 
                            
                                | Arrays in JavaScript, Part 2 | Eric Greene | 01:05:10 | JavaScript | 
                            
                                | Microsoft Cognitive Services: Search API | Scott Peterson | 00:52:52 | Cognitive Services | 
                            
                                | Windows Containers: Lessons Learned from Large Enterprise Adoption | Bruno Terkaly | 01:00:36 | Containers | 
                            
                                | Microsoft Cognitive Services: LUIS and QnA Maker | Scott Peterson | 00:59:32 | Cognitive Services, LUIS | 
                            
                                | Objects in JavaScript, Part 1 | Eric Greene | 00:52:25 | JavaScript | 
                            
                                | Objects in JavaScript, Part 2 | Eric Greene | 01:03:24 | JavaScript | 
                            
                                | Expressions, Operators, and Primitive-Type APIs in JavaScript | Eric Greene | 01:23:22 | JavaScript | 
                            
                                | Control Flow and Interations in JavaScript | Eric Greene | 01:05:02 | JavaScript | 
                            
                                | Functions in JavaScript | Eric Greene | 01:18:32 | JavaScript | 
                            
                                | JavaScript Types and Variables | Eric Greene | 01:21:22 | JavaScript | 
                            
                                | Microsoft Cognitive Services: The Emotion and Text Analytics APIs | Scott Peterson | 00:59:59 | Text Analytics API, Cognitive Services, Emotion API | 
                            
                                | Microsoft Cognitive Services: The Face API | Scott Peterson | 00:51:32 | Face API, Cognitive Services | 
                            
                                | Microsoft Cognitive Services: The Computer Vision API | Scott Peterson | 00:50:46 | Cognitive Services, Computer Vision API | 
                            
                                | Getting Started with Power BI Desktop | Scott Peterson | 00:54:59 | Power BI Desktop, Power BI | 
                            
                                | Streaming and Analytics in Power BI | Scott Peterson | 00:38:35 | Power BI | 
                            
                                | Developing Custom Visuals for Power BI | Scott Peterson | 00:58:53 | Power BI | 
                            
                                | Prototype Inheritance in JavaScript | Eric Greene | 01:30:26 | JavaScript | 
                            
                                | ASP.NET Core Middleware | Jeff Fritz | 00:34:01 | .NET Core, ASP.NET Core | 
                            
                                | Building ASP.NET Core Web UIs with Razor | Jeff Fritz | 00:54:38 | .NET Core, ASP.NET Core, Razor | 
                            
                                | Authentication and Authorization in ASP.NET Core | Jeff Fritz | 00:53:10 | .NET Core, ASP.NET Core | 
                            
                                | Mastering Angular, Part 8: Displaying Form Validation Information | Eric Greene | 01:32:35 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 7: Custom Form Validation | Eric Greene | 01:32:55 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 5: Template Forms | Eric Greene | 01:24:50 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 6: Form Validation | Eric Greene | 01:17:10 | JavaScript, Angular | 
                            
                                | Getting Started with Power BI | Scott Peterson | 00:50:42 | Power BI | 
                            
                                | Getting Started with Power BI Embedded | Scott Peterson | 00:52:31 | Power BI, Power BI Embedded | 
                            
                                | Mastering Angular, Part 4: Reactive Forms | Eric Greene | 01:08:12 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 3: Services | Eric Greene | 01:18:43 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 2: Pipes | Eric Greene | 00:57:28 | JavaScript, Angular | 
                            
                                | Mastering Angular, Part 1: Components | Eric Greene | 01:01:50 | JavaScript, Angular | 
                            
                                | Mastering React and TypeScript, Part 8: Complex User Interfaces | Eric Greene | 01:01:45 | TypeScript, React, Web | 
                            
                                | Mastering Xamarin Forms Development, Part 9: Advanced Push Notifications | Scott Peterson | 00:57:33 | Xamarin, Xamarin Forms | 
                            
                                | Mastering React and TypeScript, Part 7: Using Forms with React | Eric Greene | 01:10:46 | TypeScript, React, Web | 
                            
                                | Mastering React and TypeScript, Part 6: Composing React Components | Eric Greene | 01:09:21 | TypeScript, React, Web | 
                            
                                | Mastering Xamarin Forms Development, Part 8: Renderers, Behaviors, and Effects | Scott Peterson | 00:56:05 | Xamarin, Xamarin Forms | 
                            
                                | Mastering Xamarin Forms Development, Part 7: Push Notifications | Scott Peterson | 00:56:33 | Xamarin, Xamarin Forms | 
                            
                                | Mastering Xamarin Forms Development, Part 6: Data and Storage Strategies | Scott Peterson | 01:03:01 | Xamarin, Xamarin Forms | 
                            
                                | Mastering Xamarin Forms Development, Part 5: Dependency Services | Scott Peterson | 00:51:23 | Xamarin, Xamarin Forms | 
                            
                                | Mastering React and TypeScript, Part 5: Sorting and Filtering | Eric Greene | 01:14:20 | TypeScript, React, Web | 
                            
                                | Mastering Xamarin Forms Development, Part 3: Styles and Theming | Scott Peterson | 00:51:35 | Xamarin, Xamarin Forms | 
                            
                                | Mastering Xamarin Forms Development, Part 4: Bindings, Commands, and Converters | Scott Peterson | 00:59:53 | Xamarin, Xamarin Forms | 
                            
                                | Mastering Xamarin Forms Development, Part 2: Basic Controls and Plugins | Scott Peterson | 00:48:59 | Xamarin, Xamarin Forms | 
                            
                                | Mastering React and TypeScript, Part 4: Finish Building a React CRUD Application | Eric Greene | 01:09:46 | TypeScript, React, Web | 
                            
                                | Mastering React and TypeScript, Part 3: Build a React CRUD Application | Eric Greene | 00:48:23 | TypeScript, React, Web | 
                            
                                | Mastering React and TypeScript, Part 1: Setting Up a Development Environment | Eric Greene | 01:12:16 | TypeScript, React, Web | 
                            
                                | Mastering React and TypeScript, Part 2: Completing the Development Environment | Eric Greene | 00:53:43 | TypeScript, React, Web | 
                            
                                | Mastering Xamarin Forms Development, Part 1: Pages, Layout, and Navigation | Scott Peterson | 00:42:56 | Xamarin, Xamarin Forms | 
                            
                                | Developing UWP Apps, Part 10: Voice, Speech, and Cortana | Scott Peterson | 01:01:03 | Cortana, Universal Windows Platform | 
                            
                                | Using React with Redux | Eric Greene | 01:05:13 | Redux, React, JavaScript | 
                            
                                | Implementing Cross-Platform Microsoft Authentication in Xamarin Forms | Scott Peterson | 00:30:19 | Microsoft Graph, Xamarin, Xamarin Forms | 
                            
                                | Developing UWP Apps, Part 9: Background Tasks | Scott Peterson | 00:48:06 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 8: Cloud and Connected Services | Scott Peterson | 00:59:08 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 7: Toasts, Tiles, and Push Notifications | Scott Peterson | 01:02:50 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 6: Multimedia and Printing | Scott Peterson | 00:58:29 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 5: Bindings, Commands, and Converters | Scott Peterson | 01:02:16 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 4: Networking and Storage | Scott Peterson | 00:52:30 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 3: Custom and Advanced Controls | Scott Peterson | 00:55:43 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 2: Basic Controls and Patterns | Scott Peterson | 00:48:03 | Universal Windows Platform | 
                            
                                | Developing UWP Apps, Part 1: Layout and Navigation | Scott Peterson | 00:49:33 | Universal Windows Platform | 
                            
                                | Getting Started with Visual Studio Code | Scott Peterson | 01:01:34 | Visual Studio Code | 
                            
                                | What's New and Improved in Visual Studio 2017 | Scott Peterson | 00:50:21 | Visual Studio | 
                            
                                | Real-World DevOps with Microsoft Azure | Paul Hacker | 01:22:50 | DevOps, Azure | 
                            
                                | Introduction to Redux | Eric Greene | 01:45:35 | Redux, JavaScript, Web | 
                            
                                | Building Azure Mobile Apps | Scott Peterson | 01:20:12 | Azure | 
                            
                                | Building Azure Web Apps | Scott Peterson | 01:05:46 | Azure | 
                            
                                | Introduction to .NET Core | Kevin Jones | 00:51:32 | .NET Core | 
                            
                                | Building Azure API Apps | Scott Peterson | 00:56:42 | Azure | 
                            
                                | Building Azure Logic Apps | Scott Peterson | 00:57:29 | Azure | 
                            
                                | Using Azure Functions to Build Nanoservices | Scott Peterson | 01:10:33 | Nanoservices, Azure | 
                            
                                | Building Desktop Apps with Node.js and Electron | Eric Greene | 01:24:18 | TypeScript, Electron, React, JavaScript, Node.js | 
                            
                                | Node.js Express Web Applications | Eric Greene | 01:07:30 | JavaScript, Node.js | 
                            
                                | Creating Bots with the Microsoft Bot Framework, Part 2 | Scott Peterson | 00:50:54 | Microsoft Bot Framework | 
                            
                                | Creating Bots with the Microsoft Bot Framework, Part 1 | Scott Peterson | 00:46:16 | Microsoft Bot Framework | 
                            
                                | Node.js Express REST Services | Eric Greene | 00:57:03 | JavaScript, Node.js | 
                            
                                | Node.js Packages | Eric Greene | 00:57:48 | JavaScript, Node.js | 
                            
                                | Advanced Cortana Integration | Scott Peterson | 01:00:05 | Cortana | 
                            
                                | Node.js Files, Streams, and Buffers | Eric Greene | 01:05:10 | JavaScript, Node.js | 
                            
                                | Supercharging Enterprise Apps with Microsoft Cortana | Scott Peterson | 01:14:57 | Cortana | 
                            
                                | Node.js Modules | Eric Greene | 01:00:19 | JavaScript, Node.js | 
                            
                                | Microsoft Cortana for App Developers | Scott Peterson | 01:17:44 | Cortana | 
                            
                                | Developing with Docker | Blaize Stewart | 01:05:17 | DevOps, Docker | 
                            
                                | Creating Custom View Models | Bob Tabor | 00:14:47 | MVC, ASP.NET | 
                            
                                | Creating Azure Resource Manager Templates in Visual Studio | Paul Hacker | 00:43:12 | Visual Studio, Azure | 
                            
                                | Azure Container Services | Blaize Stewart | 00:49:51 | Docker, Azure | 
                            
                                | Introduction to Node.js | Eric Greene | 01:13:27 | JavaScript, Web, Node.js | 
                            
                                | Getting On Board with Docker | Blaize Stewart | 01:07:02 | Docker | 
                            
                                | Application Pen-Testing: Putting Your Skills to Work | Bill Sempf | 01:01:10 | Security | 
                            
                                | Game-Changing Features in ES2015 | Eric Greene | 01:06:08 | JavaScript, ES2015 | 
                            
                                | Application Pen-Testing: The OWASP Top 10 | Bill Sempf | 00:58:55 | Security | 
                            
                                | Hands-On with Azure HPC | Jeff Prosise | 00:41:11 | Azure | 
                            
                                | Hands-On with Azure Machine Learning | Jeff Prosise | 00:51:34 | Azure, Machine Learning | 
                            
                                | Implementing Localization | Bob Tabor | 00:17:16 | MVC, ASP.NET | 
                            
                                | Using Resource Files for Strings and Error Messages | Bob Tabor | 00:14:21 | MVC, ASP.NET | 
                            
                                | Visual Studio 2015, Part 1: Series Introduction | Bob Tabor | 00:03:47 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 2: What is Visual Studio? | Bob Tabor | 00:09:55 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 3: Which Edition of Visual Studio Should I Choose? | Bob Tabor | 00:06:40 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 4: Working with Projects and Solutions | Bob Tabor | 00:12:19 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 5: Understanding Visual Designers and Code Editors | Bob Tabor | 00:15:52 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 6: Ten Crucial Shortcuts to Master | Bob Tabor | 00:07:32 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 7: Customizing Visual Studio's Layout | Bob Tabor | 00:07:04 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 8: Understanding the NuGet Package Manager | Bob Tabor | 00:15:57 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 9: Debugging Basics | Bob Tabor | 00:14:49 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 10: Visual Studio Team Services | Bob Tabor | 00:15:16 | Visual Studio | 
                            
                                | Visual Studio 2015, Part 11: Visual Studio Azure Integration | Bob Tabor | 00:11:44 | Visual Studio | 
                            
                                | ViewBag Versus ViewData | Bob Tabor | 00:07:56 | MVC, ASP.NET | 
                            
                                | TempData | Bob Tabor | 00:09:43 | MVC, ASP.NET | 
                            
                                | Application Pen-Testing: Introduction and Tools | Bill Sempf | 00:58:36 | Security | 
                            
                                | Hands-On with Azure Stream Analytics | Jeff Prosise | 00:51:41 | Azure | 
                            
                                | Custom Display Templates | Bob Tabor | 00:10:06 | MVC, ASP.NET | 
                            
                                | Custom Editor Templates | Bob Tabor | 00:14:18 | MVC, ASP.NET | 
                            
                                | Introduction to Angular 2 | Jeremy Likness | 01:03:37 | JavaScript, Angular | 
                            
                                | More Web Application Attacks and Countermeasures | Ilya Pogrebensky | 01:00:27 | Security | 
                            
                                | New Features in C# 6 and Visual Studio 2015 | Kathleen Dollard | 01:10:26 | C#, Visual Studio | 
                            
                                | Architectural Spikes and Setting Up the Solution | Bob Tabor | 00:21:49 | Architecture | 
                            
                                | Common Web Application Attacks and Countermeasures | Ilya Pogrebensky | 01:00:21 | Security, Web | 
                            
                                | Using Dependency Injection to Decouple Layers | Bob Tabor | 00:15:08 | Architecture | 
                            
                                | Understanding Cross-Cutting Concerns | Bob Tabor | 00:11:37 | Architecture | 
                            
                                | Chatty versus Chunky Layer Interactions | Bob Tabor | 00:07:16 | Architecture | 
                            
                                | Designing Data Transfer Objects | Bob Tabor | 00:11:53 | Architecture | 
                            
                                | Understanding the Application Services Layer | Bob Tabor | 00:10:27 | Architecture | 
                            
                                | Understanding the Web Services Layer | Bob Tabor | 00:21:42 | Architecture | 
                            
                                | Filters | Bob Tabor | 00:17:37 | MVC, ASP.NET | 
                            
                                | Areas | Bob Tabor | 00:08:31 | MVC, ASP.NET | 
                            
                                | Bundling and Minification | Bob Tabor | 00:30:56 | MVC, ASP.NET | 
                            
                                | Authentication and Authorization | Ilya Pogrebensky | 00:53:31 | Security | 
                            
                                | Series Introduction | Bob Tabor | 00:09:11 | Architecture | 
                            
                                | What is Architecture? | Bob Tabor | 00:17:59 | Architecture | 
                            
                                | When and How Architecture Happens | Bob Tabor | 00:13:11 | Architecture | 
                            
                                | Change is the Biggest Challenge in Software Development | Bob Tabor | 00:17:14 | Architecture | 
                            
                                | Understanding the Layered Architecture Pattern | Bob Tabor | 00:20:08 | Architecture | 
                            
                                | Understanding the Domain Layer | Bob Tabor | 00:17:01 | Architecture | 
                            
                                | Understanding the Presentation Layer | Bob Tabor | 00:23:23 | Architecture | 
                            
                                | Understanding the Persistence Layer | Bob Tabor | 00:24:09 | Architecture | 
                            
                                | Custom Routes | Bob Tabor | 00:31:19 | MVC, ASP.NET | 
                            
                                | RESTful URL Design | Bob Tabor | 00:15:47 | MVC, ASP.NET | 
                            
                                | Attribute Routing | Bob Tabor | 00:16:19 | MVC, ASP.NET | 
                            
                                | Partial Views | Bob Tabor | 00:10:37 | MVC, ASP.NET | 
                            
                                | Child Actions | Bob Tabor | 00:08:19 | MVC, ASP.NET | 
                            
                                | Caching Actions and Child Actions | Bob Tabor | 00:15:58 | MVC, ASP.NET | 
                            
                                | Returning Views, HTTP Errors and Redirecting Requests | Bob Tabor | 00:12:50 | MVC, ASP.NET | 
                            
                                | Layout Pages, RenderBody, RenderPage, and RenderSection | Bob Tabor | 00:15:42 | MVC, ASP.NET | 
                            
                                | Web API Serialization, Model Binding, and Validation | Tony Sneed | 00:54:32 | Web API, ASP.NET | 
                            
                                | Introduction to Cross-Site Scripting and the AntiForgeryToken | Bob Tabor | 00:13:27 | MVC, ASP.NET | 
                            
                                | Styling HTML Helper Method Output | Bob Tabor | 00:15:31 | MVC, ASP.NET | 
                            
                                | Securing Databases | Ilya Pogrebensky | 00:39:19 | Security, Database | 
                            
                                | Introduction to Validation | Bob Tabor | 00:22:57 | MVC, ASP.NET | 
                            
                                | Creating an HTML Form with Labels and Other Form Controls | Bob Tabor | 00:30:54 | MVC, ASP.NET | 
                            
                                | Adding Client-Side and Unobtrusive Validation | Bob Tabor | 00:13:34 | MVC, ASP.NET | 
                            
                                | Preserving Data Annotations Using a Partial Metadata Class | Bob Tabor | 00:09:42 | MVC, ASP.NET | 
                            
                                | Understanding MVC Application Architecture and the View Model | Bob Tabor | 00:12:03 | MVC, ASP.NET | 
                            
                                | Introduction to Model Binding | Bob Tabor | 00:20:47 | MVC, ASP.NET | 
                            
                                | Introduction to Data Annotations | Bob Tabor | 00:10:56 | MVC, ASP.NET | 
                            
                                | Cryptography | Ilya Pogrebensky | 00:49:40 | Security | 
                            
                                | Working with RouteValueDictionary in HTML Helper Navigation Methods | Bob Tabor | 00:12:22 | MVC, ASP.NET | 
                            
                                | Introduction to ASP.NET MVC 5 | Bob Tabor | 00:09:59 | MVC, ASP.NET | 
                            
                                | Building your First ASP.NET MVC Application | Bob Tabor | 00:26:26 | MVC, ASP.NET | 
                            
                                | Understanding the Model-View-Controller Design Pattern | Bob Tabor | 00:07:15 | MVC, ASP.NET | 
                            
                                | Understanding "Convention over Configuration" | Bob Tabor | 00:07:05 | MVC, ASP.NET | 
                            
                                | Passing Data from the Controller to the View | Bob Tabor | 00:04:23 | MVC, ASP.NET | 
                            
                                | Defining a View and Layout | Bob Tabor | 00:12:36 | MVC, ASP.NET | 
                            
                                | Helper Methods in the View | Bob Tabor | 00:07:07 | MVC, ASP.NET | 
                            
                                | Understanding Razor Syntax Basics | Bob Tabor | 00:25:10 | MVC, ASP.NET | 
                            
                                | Generating a Scaffolded App from an Entity Data Model | Bob Tabor | 00:12:21 | MVC, ASP.NET | 
                            
                                | Introduction to Routing | Bob Tabor | 00:21:41 | MVC, ASP.NET | 
                            
                                | Basic Security Concepts | Ilya Pogrebensky | 00:50:59 | Security | 
                            
                                | Windows 10 In-Place Upgrade Troubleshooting and Restoration | Dave Franklyn | 00:50:04 | Windows 10 | 
                            
                                | Getting Started with Windows 10 | Dave Franklyn | 00:58:04 | Windows 10, IT Pro, Active Directory | 
                            
                                | What's New for Web API in ASP.NET 5 | Tony Sneed | 00:55:22 | Web API, ASP.NET | 
                            
                                | Introduction to Xamarin Forms | Jeff Prosise | 00:53:25 | Xamarin, Xamarin Forms | 
                            
                                | Introduction to Hadoop Using the Syncfusion Big Data Platform | Jim Counts | 01:52:23 | Big Data Platform, Hadoop, Big Data | 
                            
                                | Web API Hosting | Tony Sneed | 00:53:35 | Web API, ASP.NET | 
                            
                                | Introduction to ASP.NET Web API | Tony Sneed | 00:56:56 | Web API, ASP.NET | 
                            
                                | Writing Roslyn Analyzers and Code Fixes | John Robbins | 01:33:08 | Code Fix, C#, Analyzer, Roslyn | 
                            
                                | Developing HTML5 Games from Scratch: Creating and Managing Game Objects | G. Andrew Duthie | 00:39:24 | HTML5, JavaScript, Web | 
                            
                                | Security Threats, Principles, and Fundamentals | Bill Sempf | 00:40:05 | Security | 
                            
                                | Entity Framework in N-Tier Applications | Tony Sneed | 01:05:57 | Entity Framework | 
                            
                                | Intellectual Property for Technologists: Trademarks, Patents, and Trade Secrets | John Petersen | 01:09:01 | Software Law | 
                            
                                | Intellectual Property for Technologists: Introduction to IP and Copyrights | John Petersen | 00:54:34 | Software Law | 
                            
                                | Getting Started with Graph Databases using Neo4j | Brian C. Lanham | 01:40:15 | Neo4j | 
                            
                                | Dependency Injection with Unity | Sathyaish Chakravarthy | 01:30:12 | .NET | 
                            
                                | Introduction to Visual Studio Extensions, Part 2 | Eric Greene | 00:59:52 | Visual Studio | 
                            
                                | Introduction to Visual Studio Extensions, Part 1 | Eric Greene | 00:58:32 | Visual Studio | 
                            
                                | ETW Disk I/O and Machine Information | Bruce Dawson | 00:44:00 | Event Tracing for Windows | 
                            
                                | AngularJS: Debugging and Performance | Jeremy Likness | 00:58:38 | JavaScript, Angular | 
                            
                                | SignalR Extensibility | Kevin Griffin | 00:36:47 | ASP.NET, SignalR, Web | 
                            
                                | ETW Custom Events and Idle-Thread Analysis | Bruce Dawson | 00:49:19 | Event Tracing for Windows | 
                            
                                | Building Apps with Unity | Russ Fustino | 00:31:02 | Unity | 
                            
                                | AngularJS: Advanced Directives | Dave Baskin | 01:00:03 | JavaScript, Angular | 
                            
                                | Introduction to NServiceBus | Mitch Harpur | 01:15:36 | NServiceBus | 
                            
                                | Introduction to Profiling with Event Tracing for Windows | Bruce Dawson | 00:48:40 | Event Tracing for Windows | 
                            
                                | SignalR Self-Hosting | Kevin Griffin | 00:20:45 | ASP.NET, SignalR, Web | 
                            
                                | WPF Basic Styling | Colin Melia | 01:26:11 | WPF | 
                            
                                | The MEAN Stack, Part 2: Scaffolding and Frameworks | Josh Lane | 00:41:28 | Web, MEAN | 
                            
                                | The MEAN Stack, Part 1: Introduction | Josh Lane | 01:28:45 | Web, MEAN | 
                            
                                | Angular UI-Router: How to Build Complex HTML User Interfaces | Mitch Harpur | 01:32:27 | JavaScript, Angular, Web | 
                            
                                | AngularJS: Testing | Jeremy Likness | 01:06:06 | JavaScript, Angular | 
                            
                                | MongoDB for Developers | Noel Stieglitz | 01:12:44 | MongoDB, Database, Web | 
                            
                                | Crystal Reports: Parameter Fields | Joyce Weldon | 01:02:05 | Crystal Reports | 
                            
                                | AngularJS: Directives Fundamentals | Dave Baskin | 00:52:40 | JavaScript, Angular | 
                            
                                | Security for Internet-Facing Servers | Dave Franklyn | 01:22:18 | Security, IT Pro | 
                            
                                | AngularJS: Routes | Jeremy Likness | 00:52:07 | JavaScript, Angular | 
                            
                                | Creating PowerShell Cmdlets with PowerShell | Richard Macdonald | 00:20:04 | PowerShell | 
                            
                                | Creating PowerShell Cmdlets with C# | Richard Macdonald | 00:33:39 | PowerShell | 
                            
                                | Developing HTML5 Games from Scratch: Handling Input | G. Andrew Duthie | 00:51:30 | HTML5, JavaScript, Web | 
                            
                                | Mastering Text with PowerShell | Richard Macdonald | 01:43:53 | PowerShell | 
                            
                                | AngularJS: Web Services | Jeremy Likness | 01:03:46 | JavaScript, Angular | 
                            
                                | Managing Layout in Xamarin.iOS | Mark Smith | 01:35:58 | Xamarin | 
                            
                                | Unit Testing with Visual Studio 2013 | Mike Vincent | 00:53:24 | Team Foundation Server | 
                            
                                | Crystal Reports: Formulas | Joyce Weldon | 01:34:33 | Crystal Reports | 
                            
                                | SignalR Performance | Kevin Griffin | 00:26:50 | ASP.NET, SignalR, Web | 
                            
                                | WPF Basic Binding | Colin Melia | 01:02:06 | WPF | 
                            
                                | Debugging and Unit-Testing ASP.NET Routes | Walt Ritscher | 00:53:23 | MVC, ASP.NET | 
                            
                                | WPF Layout | Colin Melia | 00:58:03 | WPF | 
                            
                                | Developing HTML5 Games from Scratch: Drawing and Animation | G. Andrew Duthie | 00:35:48 | HTML5, JavaScript, Web | 
                            
                                | Control Templates | Charles Petzold | 01:13:01 | XAML | 
                            
                                | LINQ to Entities | Tony Sneed | 00:52:03 | Entity Framework | 
                            
                                | Getting Started with Breeze.js | Noel Stieglitz | 00:59:09 | Breeze, JavaScript, Web | 
                            
                                | Developing HTML5 Games from Scratch: A Solid Foundation | G. Andrew Duthie | 01:05:29 | HTML5, JavaScript, Web | 
                            
                                | Dynamic Code Generation: Writing Code that Writes Code | Sathyaish Chakravarthy | 01:57:59 | .NET | 
                            
                                | AngularJS: Services | Jeremy Likness | 01:16:03 | JavaScript, Angular | 
                            
                                | WPF Panel Controls | Colin Melia | 01:03:15 | WPF | 
                            
                                | ASP.NET MVC 5 Attribute Routing | Walt Ritscher | 00:42:12 | MVC, ASP.NET | 
                            
                                | Windows Debugger (WinDBG) for Native Debugging | John Robbins | 02:37:27 | Debugging | 
                            
                                | Dynamic Layout Management in Xamarin.Android | Mark Smith | 01:46:55 | Xamarin | 
                            
                                | Introduction to HTML5 for Game Developers | G. Andrew Duthie | 00:47:11 | HTML5, JavaScript, Web | 
                            
                                | WPF Basic Controls | Colin Melia | 01:04:03 | WPF | 
                            
                                | Impressive Data Visualizations with D3 | Dave Baskin | 00:46:29 | D3, JavaScript, Web | 
                            
                                | Animation | Charles Petzold | 01:17:06 | XAML | 
                            
                                | Crystal Reports: Reports Design Fundamentals, Part 2 | Joyce Weldon | 01:20:13 | Crystal Reports | 
                            
                                | Views and Controls in Xamarin.iOS | Mark Smith | 01:58:29 | Xamarin | 
                            
                                | Rudiments of ASP.NET Routing | Walt Ritscher | 01:14:26 | MVC, ASP.NET | 
                            
                                | AngularJS: Dependency Injection | Jeremy Likness | 00:49:08 | JavaScript, Angular | 
                            
                                | JavaScript Gotchas | Rachel Appel | 00:22:42 | JavaScript, Web | 
                            
                                | SignalR Scaling | Kevin Griffin | 00:28:12 | ASP.NET, SignalR, Web | 
                            
                                | Code-First Development with Entity Framework | Tony Sneed | 00:50:55 | Entity Framework | 
                            
                                | Views and Controls in Xamarin.Android | Mark Smith | 01:26:07 | Xamarin | 
                            
                                | The Seven Tenets of an Engaging and Natural User Experience | Tim Huckaby | 01:02:55 | User Experience | 
                            
                                | Vector Graphics | Charles Petzold | 01:14:44 | XAML | 
                            
                                | LINQ: Language Integrated Query | Tony Sneed | 00:52:39 | Entity Framework, C# | 
                            
                                | Creating Electronic Reports with PowerShell | Richard Macdonald | 01:52:47 | PowerShell | 
                            
                                | CSS3 Styles for Tables | Margaret Meier de Cox | 00:52:18 | CSS3, Web | 
                            
                                | Node.js for the Confused | Josh Lane | 00:43:39 | Web, Node.js | 
                            
                                | Entity Framework Architecture | Tony Sneed | 00:53:15 | Entity Framework | 
                            
                                | Crystal Reports: Reports Design Fundamentals | Joyce Weldon | 01:02:16 | Crystal Reports | 
                            
                                | Introduction to iOS Development with Xamarin and C# | Mark Smith | 01:03:14 | Xamarin | 
                            
                                | C# Raw Data and REST Service Access | Colin Melia | 01:05:19 | C# | 
                            
                                | iOS Development with Objective-C: Now You're Serious | Paul Usher | 00:34:08 | Mobile, iOS | 
                            
                                | Windows Server Hyper-V Real-World Best Practices | Bret Fisher | 00:40:52 | Hyper-V, IT Pro | 
                            
                                | Data Visualization and MVVM | Charles Petzold | 01:12:11 | XAML | 
                            
                                | Tile and Toast Notifications | Jeffrey Richter | 02:22:27 | Windows Store Apps | 
                            
                                | Windows Runtime Networking APIs | Jeffrey Richter | 01:55:37 | Windows Store Apps | 
                            
                                | C# ASMX and WCF Service Access | Colin Melia | 01:10:00 | C# | 
                            
                                | SOLID Principles | Noel Stieglitz | 00:34:33 | Architecture | 
                            
                                | Introduction to Linux | Blaize Stewart | 01:15:22 | Linux | 
                            
                                | JavaScript Soup to Nuts: Back to Basics | Joel Cochran | 00:29:23 | JavaScript | 
                            
                                | Azure Notification Hubs | Brian C. Lanham | 00:45:07 | Azure | 
                            
                                | SQL Server and BLOBs | Mark Dunn | 01:02:09 | SQL Server, Database | 
                            
                                | CSS3 Styles for Forms | Margaret Meier de Cox | 00:55:10 | CSS3, Web | 
                            
                                | Entity Framework Overview and Quick Start | Tony Sneed | 00:34:53 | Entity Framework | 
                            
                                | CSS3 Navigation Styles and Responsive Design | Margaret Meier de Cox | 00:51:51 | CSS3, Web | 
                            
                                | Bugs: Causes and Solutions (Native Code) | John Robbins | 00:42:11 | Debugging | 
                            
                                | Solving Memory Problems and the Debug C Run-Time | John Robbins | 00:37:53 | Debugging | 
                            
                                | AngularJS: Advanced Filters | Jeremy Likness | 00:51:45 | JavaScript, Angular | 
                            
                                | Building for Native Debuggability | John Robbins | 00:45:25 | Debugging | 
                            
                                | Debugging During Coding (Native Code) | John Robbins | 00:38:27 | Debugging | 
                            
                                | Operating System Support and Debugger Concepts | John Robbins | 00:34:24 | Debugging | 
                            
                                | Visual Studio Native Process Debugging Tricks | John Robbins | 00:16:53 | Debugging | 
                            
                                | Visual Studio Native Breakpoints | John Robbins | 00:43:54 | Debugging | 
                            
                                | Visual Studio Native Expression Evaluation | John Robbins | 00:29:11 | Debugging | 
                            
                                | More Visual Studio Native Debugging Tricks | John Robbins | 00:41:53 | Debugging | 
                            
                                | Mastering Assembly Language | John Robbins | 01:45:17 | Debugging | 
                            
                                | Reverse Engineering | John Robbins | 01:24:17 | Debugging | 
                            
                                | Building Your First Android App | Blaize Stewart | 01:06:57 | Mobile, Android | 
                            
                                | SignalR Security | Kevin Griffin | 00:56:20 | ASP.NET, SignalR, Web | 
                            
                                | Stream Input and Output | Jeffrey Richter | 01:25:12 | Windows Store Apps | 
                            
                                | Introduction to Android Development with Xamarin and C# | Mark Smith | 01:10:29 | Xamarin | 
                            
                                | C# Unit Testing | Colin Melia | 01:07:53 | C# | 
                            
                                | Mobile-First Responsive Design using LESS, Bootstrap, and Angular | Mitch Harpur | 01:40:13 | LESS, Bootstrap, JavaScript, Angular, Web | 
                            
                                | SQL Server and XML | Mark Dunn | 00:45:29 | SQL Server, Database | 
                            
                                | Architecting PHP Apps | Blaize Stewart | 01:09:12 | PHP | 
                            
                                | Database Security | Mark Dunn | 01:02:06 | SQL Server, Database | 
                            
                                | C# Application and Component Types | Colin Melia | 01:08:55 | C# | 
                            
                                | Storage Folders and Files | Jeffrey Richter | 01:36:46 | Windows Store Apps | 
                            
                                | Matrix Transforms | Charles Petzold | 01:07:56 | XAML | 
                            
                                | Getting Started with Visual Studio ALM and TFS 2013 | Mike Vincent | 00:56:08 | Team Foundation Server | 
                            
                                | Transactions and Locking | Mark Dunn | 00:53:15 | SQL Server, Database | 
                            
                                | Windows Store Apps Process Model | Jeffrey Richter | 01:23:59 | Windows Store Apps | 
                            
                                | Windows Store App Package Data and Roaming | Jeffrey Richter | 00:31:31 | Windows Store Apps | 
                            
                                | Windows Server Hyper-V Step by Step | Bret Fisher | 00:56:12 | Hyper-V, IT Pro | 
                            
                                | Windows Store Packages: Building, Deploying, and Installing | Jeffrey Richter | 01:26:18 | Windows Store Apps | 
                            
                                | What's New in WPF 4.5 | Walt Ritscher | 01:00:09 | WPF | 
                            
                                | Elements, Controls, and Layout | Charles Petzold | 01:09:19 | XAML | 
                            
                                | AngularJS: Scope and Digest Loop | Jeremy Likness | 01:03:37 | JavaScript, Angular | 
                            
                                | A Design Patterns Refresher | Brian C. Lanham | 00:51:22 | Patterns | 
                            
                                | SignalR Hubs and Client Management | Kevin Griffin | 00:49:06 | ASP.NET, SignalR, Web | 
                            
                                | C# File Access | Colin Melia | 00:56:57 | C# | 
                            
                                | SignalR in a Flash | Kevin Griffin | 00:29:27 | ASP.NET, SignalR, Web | 
                            
                                | XAML Fundamentals | Charles Petzold | 00:55:26 | XAML | 
                            
                                | Getting Started with Ember.js | Noel Stieglitz | 00:59:03 | Ember, JavaScript, Web | 
                            
                                | NoSQL for the Confused | Josh Lane | 01:31:09 | NoSQL | 
                            
                                | Mastering Google Chrome's Developer Tools | Joel Cochran | 01:04:49 | Chrome, JavaScript | 
                            
                                | Building Your First iOS App with Objective-C | Paul Usher | 00:22:46 | Mobile, iOS | 
                            
                                | Cursors | Mark Dunn | 00:38:58 | SQL Server, Database | 
                            
                                | CSS3 Responsive Design | Margaret Meier de Cox | 00:56:17 | CSS3, Web | 
                            
                                | Web Runtime Architecture | Tobin Titus | 00:21:00 | Web | 
                            
                                | Triggers | Mark Dunn | 00:53:28 | SQL Server, Database | 
                            
                                | Routes, Controllers, and Actions | Kevin Hazzard | 00:54:35 | Web API, ASP.NET, Web | 
                            
                                | Migrating ASP.NET Web Forms to MVC | Rachel Appel | 00:49:30 | MVC, ASP.NET | 
                            
                                | Microsoft Fakes | Dave Baskin | 00:33:27 | Testing | 
                            
                                | Advanced Client Security | Dave Franklyn | 01:04:51 | Security, IT Pro | 
                            
                                | LESS is More | Mitch Harpur | 01:15:21 | LESS, JavaScript, Web | 
                            
                                | CSS3 Media Queries | Margaret Meier de Cox | 00:53:49 | CSS3, Web | 
                            
                                | Spicing Up ASP.NET MVC Apps with KnockoutJS | Joel Cochran | 00:51:03 | MVC, Knockout, ASP.NET | 
                            
                                | Raspberry Pi: Programming GPIO | Tom Marshall | 00:36:10 | Raspberry Pi | 
                            
                                | Thinking in HTTP | Kevin Hazzard | 00:40:48 | Web API, ASP.NET, Web | 
                            
                                | Web Services with PHP | Blaize Stewart | 00:50:54 | PHP | 
                            
                                | Fundamentals of Object-Oriented Software Development | Rachel Appel | 00:43:38 | Patterns, Architecture | 
                            
                                | CSS3 Page Layout | Margaret Meier de Cox | 00:52:58 | CSS3, Web | 
                            
                                | Building Next-Generation Social Solutions with Yammer | Scott Peterson | 00:45:03 | Yammer, JavaScript, Web | 
                            
                                | Securing Servers | Dave Franklyn | 01:09:23 | Security, IT Pro | 
                            
                                | CSS3 Typography, Fonts, and Multi-Column Layout | Margaret Meier de Cox | 00:48:39 | CSS3, Web | 
                            
                                | Network Security | Dave Franklyn | 01:16:40 | Security, IT Pro | 
                            
                                | C# Application Settings | Colin Melia | 00:46:49 | C# | 
                            
                                | User-Defined Functions | Mark Dunn | 00:49:40 | SQL Server, Database | 
                            
                                | C# Data Structures | Colin Melia | 00:52:47 | C# | 
                            
                                | Build Your First ASP.NET MVC App | Rachel Appel | 00:44:06 | MVC, ASP.NET | 
                            
                                | Introduction to Windows Communication Foundation (WCF) | Paul Mehner | 00:53:22 | WCF | 
                            
                                | Stored Procedures | Mark Dunn | 00:58:47 | SQL Server, Database | 
                            
                                | CSS3 Transitions and Transforms | Margaret Meier de Cox | 00:49:30 | CSS3, Web | 
                            
                                | Raspberry Pi Startup | Tom Marshall | 00:17:10 | Raspberry Pi | 
                            
                                | C# Program Flow | Colin Melia | 01:12:10 | C# | 
                            
                                | C# Basics | Colin Melia | 00:50:30 | C# | 
                            
                                | More PHP Design Patterns | Blaize Stewart | 01:13:08 | PHP | 
                            
                                | PHP Design Patterns | Blaize Stewart | 01:45:28 | PHP | 
                            
                                | Writing T-SQL Scripts | Mark Dunn | 01:03:02 | SQL Server, Database | 
                            
                                | Introduction to Security | Dave Franklyn | 01:23:37 | Security, IT Pro | 
                            
                                | Managing Image File Metadata | Tom Marshall | 00:35:33 | Graphics | 
                            
                                | From the Trenches: Creating and Publishing NuGet Packages | Scott Peterson | 00:24:24 | NuGet, Visual Studio | 
                            
                                | CSS3 Color and Special Effects | Margaret Meier de Cox | 00:58:22 | CSS3, Web | 
                            
                                | JavaScript for C# Programmers | Mitch Harpur | 01:18:34 | JavaScript, Web | 
                            
                                | WCF Behaviors and Extensibility | Paul Mehner | 00:48:02 | WCF | 
                            
                                | Fundamentals of AngularJS | Jeremy Likness | 01:15:02 | JavaScript, Angular | 
                            
                                | When It's DNS, It's ALWAYS DNS! | Dave Franklyn | 01:17:21 | Active Directory | 
                            
                                | Views | Mark Dunn | 00:38:58 | SQL Server, Database | 
                            
                                | Data Access with PHP | Blaize Stewart | 00:53:26 | PHP | 
                            
                                | Introduction to Windows Image Processing APIs | Tom Marshall | 00:47:00 | Graphics | 
                            
                                | Working with Built-In Functions | Mark Dunn | 01:25:34 | SQL Server, Database | 
                            
                                | Getting Started with CSS3 | Margaret Meier de Cox | 00:49:31 | CSS3, Web | 
                            
                                | Data Types | Mark Dunn | 00:35:59 | SQL Server, Database | 
                            
                                | Common PHP APIs | Blaize Stewart | 01:06:43 | PHP | 
                            
                                | Introduction to Knockout.js | Jim Wang | 00:43:55 | Knockout, Web | 
                            
                                | Introduction to Test-Driven Development | Sergio Loscialo | 00:57:42 | Testing | 
                            
                                | Modifying Data | Mark Dunn | 00:53:05 | SQL Server, Database | 
                            
                                | MVVM with Portable Class Library | Colin Melia | 00:37:21 | Patterns | 
                            
                                | Building a Live Grid with ASP.NET Web API and SignalR | Jim Wang | 01:06:30 | ASP.NET, SignalR, Web | 
                            
                                | TypeScript => Essentially JavaScript Eventually | Mitch Harpur | 01:13:46 | TypeScript, JavaScript, Web | 
                            
                                | OAuth 2.0 Up and Running | Blaize Stewart | 00:50:01 | OAuth | 
                            
                                | Introduction to WinDBG | John Robbins | 01:04:08 | Debugging | 
                            
                                | SOS Commands and Minidumps | John Robbins | 01:38:32 | Debugging | 
                            
                                | Using Group Policies to Simplify Domain Management | Dave Franklyn | 01:28:50 | Active Directory | 
                            
                                | HTML5 Canvas API | Jeff Prosise | 01:03:00 | HTML5, JavaScript, Web | 
                            
                                | IntelliTrace | John Robbins | 01:22:37 | Debugging | 
                            
                                | Subqueries | Mark Dunn | 00:59:02 | SQL Server, Database | 
                            
                                | Node.js on Windows: A Crash Course | Jim Wang | 00:33:24 | Web, Node.js | 
                            
                                | Pimp My Perfect Developer Machine – Windows 8 and the Client Hyper-V | Dave Franklyn | 01:09:49 | Windows, Hyper-V | 
                            
                                | Mobile Applications with PhoneGap | Blaize Stewart | 01:25:20 | Mobile, PhoneGap | 
                            
                                | Understanding Backbone: A Hands-On Approach | Mitch Harpur | 01:38:17 | Backbone, JavaScript, Web | 
                            
                                | Enterprise JavaScript Best Practices | Jeremy Likness | 01:15:34 | JavaScript, Web | 
                            
                                | Understanding Azure Mobile Services | John Garland | 00:50:10 | Mobile, Azure | 
                            
                                | Performing I/O-Bound Asynchronous Operations | Jeffrey Richter | 01:35:06 | .NET, Multithreading | 
                            
                                | More Visual Studio Debugging Tricks | John Robbins | 00:45:04 | Debugging | 
                            
                                | Introduction to PHP | Blaize Stewart | 01:17:58 | PHP | 
                            
                                | Expression Evaluator | John Robbins | 00:40:06 | Debugging | 
                            
                                | Advanced Breakpoints | John Robbins | 00:44:07 | Debugging | 
                            
                                | Summarizing Data | Mark Dunn | 00:52:26 | SQL Server, Database | 
                            
                                | Modular JavaScript Architectures | Mitch Harpur | 01:06:25 | JavaScript, Web, Architecture | 
                            
                                | Enterprise Architecture Best Practices | Todd Fine | 01:04:15 | Architecture | 
                            
                                | Symbols and Source Servers | John Robbins | 00:44:44 | Debugging | 
                            
                                | Debugging During Coding | John Robbins | 00:45:48 | Debugging | 
                            
                                | Visual Studio Process Debugging Tricks | John Robbins | 00:18:58 | Debugging | 
                            
                                | Introduction to Microsoft Active Directory Domain Services | Dave Franklyn | 01:09:24 | Active Directory | 
                            
                                | Introduction to WinRT | Jeff Prosise | 00:55:39 | Windows Store Apps | 
                            
                                | Multi-Table Queries | Mark Dunn | 00:53:29 | SQL Server, Database | 
                            
                                | Understanding RequireJS | Mitch Harpur | 01:19:37 | JavaScript, RequireJS, Web | 
                            
                                | Building for .NET Debuggability | John Robbins | 00:51:52 | Debugging | 
                            
                                | Bugs: Causes and Solutions | John Robbins | 00:42:23 | Debugging | 
                            
                                | The Debugging Process | John Robbins | 00:26:30 | Debugging | 
                            
                                | HTML5 Indexed DB | Jeff Prosise | 00:55:27 | HTML5, JavaScript, Web | 
                            
                                | HTML5 File APIs | Jeff Prosise | 00:38:43 | HTML5, JavaScript, Web | 
                            
                                | HTML5 Web Storage | Jeff Prosise | 00:30:17 | HTML5, JavaScript, Web | 
                            
                                | HTML5 Networking APIs | Jeff Prosise | 00:44:14 | HTML5, JavaScript, Web | 
                            
                                | Facebook Integration with JavaScript | Blaize Stewart | 01:01:01 | Facebook, JavaScript, Web | 
                            
                                | Getting Started with jQuery Mobile | Blaize Stewart | 01:19:34 | Mobile, jQuery Mobile, jQuery | 
                            
                                | Microsoft Azure Storage Service Overview | Jeffrey Richter | 00:41:25 | Azure | 
                            
                                | Microsoft Azure Storage: Blobs | Jeffrey Richter | 01:52:44 | Azure | 
                            
                                | Microsoft Azure Storage: Tables | Jeffrey Richter | 01:11:15 | Azure | 
                            
                                | Microsoft Azure Storage: Queues | Jeffrey Richter | 01:48:31 | Azure | 
                            
                                | Microsoft Azure Cloud Service Fundamentals | Jeffrey Richter | 01:03:51 | Azure | 
                            
                                | Microsoft Azure Cloud Service Role Features | Jeffrey Richter | 00:41:41 | Azure | 
                            
                                | Updating a Microsoft Azure Cloud Service | Jeffrey Richter | 00:27:17 | Azure | 
                            
                                | Getting Started with Microsoft Azure | Jeffrey Richter | 00:43:39 | Azure | 
                            
                                | Thread Fundamentals | Jeffrey Richter | 01:11:46 | .NET, Multithreading | 
                            
                                | Performing Compute-Bound Asynchronous Operations | Jeffrey Richter | 01:21:10 | .NET, Multithreading | 
                            
                                | Thread Synchronization Primitives | Jeffrey Richter | 01:33:11 | .NET, Multithreading | 
                            
                                | Thread Synchronization Locks | Jeffrey Richter | 01:26:59 | .NET, Multithreading | 
                            
                                | Generics | Jeffrey Richter | 01:31:57 | C# | 
                            
                                | Garbage Collection | Jeffrey Richter | 01:35:27 | .NET, C# | 
                            
                                | Background Tasks in Windows Store Apps | Jeff Prosise | 01:02:40 | Windows Store Apps | 
                            
                                | Thinking About Performance | John Robbins | 00:36:18 | Performance | 
                            
                                | The Performance of Everyday Things | John Robbins | 00:56:03 | Performance | 
                            
                                | Understanding the Visual Studio Profiler | John Robbins | 00:22:31 | Performance | 
                            
                                | jQuery Events | Jeff Prosise | 01:01:10 | jQuery, JavaScript, Web | 
                            
                                | jQuery Effects | Jeff Prosise | 00:41:13 | jQuery, JavaScript, Web | 
                            
                                | jQuery AJAX | Jeff Prosise | 00:59:11 | jQuery, JavaScript, Web | 
                            
                                | Introduction to SQL | Mark Dunn | 01:10:14 | SQL Server, Database | 
                            
                                | SQL Server 2012 Tools | Mark Dunn | 00:29:08 | SQL Server, Database | 
                            
                                | Single-Table Queries | Mark Dunn | 00:55:22 | SQL Server, Database | 
                            
                                | Twitter Bootstrap | Jim Wang | 00:44:21 | Bootstrap, Web | 
                            
                                | Windows Architecture | John Robbins | 00:27:37 | Performance | 
                            
                                | .NET Architecture | John Robbins | 00:24:35 | Performance | 
                            
                                | Performance Counters | John Robbins | 00:21:49 | Performance | 
                            
                                | Memory Profiling with the Visual Studio Profiler | John Robbins | 00:55:15 | Performance | 
                            
                                | Orientation and Snapping in Windows Store Apps | Jeff Prosise | 00:38:55 | Windows Store Apps | 
                            
                                | Contracts in Windows Store Apps | Jeff Prosise | 00:58:27 | Windows Store Apps | 
                            
                                | Pointer Input in Windows Store Apps | Jeff Prosise | 00:42:46 | Windows Store Apps | 
                            
                                | Authoring jQuery Plugins | Jeff Prosise | 00:33:20 | jQuery, JavaScript, Web | 
                            
                                | Introduction to jQuery | Jeff Prosise | 01:01:14 | jQuery, JavaScript, Web | 
                            
                                | PowerShell for Developers | John Robbins | 01:18:55 | PowerShell | 
                            
                                | HTML5 Web Workers | Jeff Prosise | 00:38:37 | HTML5, JavaScript, Web | 
                            
                                | HTML5 Geolocation API | Jeff Prosise | 00:33:19 | HTML5, JavaScript, Web |