Adventures in .NET

In this week’s episode of Adventures in .NET the panel interviews Wade Gausden, who is well known for his website dotnetcoretutorials.com. When Wade got started in .NET around .NET 2.0 the documentation was terrible, so he started this website where he would write posts about the problems he ran into and how he solved them. The panel discusses how as .NET and C# have grown and evolved, making things easier. 

Wade shares his experience using .NET Core on a greenfield project he was consulting on. Caleb shared his experience porting over to .NET Core from .NET Framework. While .NET Core was a breath of fresh air, they had to use a lot of workarounds to get the result they wanted. Wade commiserates telling the panel that one of his most popular posts still is about how to send an email in .NET Core. 

Caleb expresses his appreciation for all the work they did to make porting over easier in .NET 2.. He answers Wade’s questions about how they ported over. Caleb tells him how he spent months figuring out how to rearchitect and that their main pain point was code first migrations. Caleb shares a little about his current project, where they are using .NET Core 2.0 and Angular 6. His next project will be using .NET Core 3.0 and Angular 8.

This leads the panel to discuss the treasures that can be found in the release of .NET 3.0. They discuss null reference management and Blazor. The panel compares webforms and Blazor, with all they get with Blazor, webforms are dead. The panel is sure that nullable reference types will get a lot of use along with iAsyncEnumerble. 

Other new releases in .NET 3.0 they are not so sure will get as much use, such as the range type. They discuss the potential of default interface methods once people wrap their minds around the idea. Wade explains what IL Linker Support is and what it does, it is basically tree shaking for .NET. 

The panel wonders at what it means for Winforms and WPF apps now that .NET Core supports desktop apps. They think that it won’t actually get that much use. Caleb speculates that it was a business move to help prepare for .NET 5 as a way to preserve it’s cross platforming capabilities. 

The panel asks Wade about his favorite posts on his site. Wade explains that he loves the multipart series, his most recent being on the use of dapper. Dapper runs SQL statements and helps protect you from SQL injections and other things of that nature. He wrote it to help a friend of his understand the importance of knowing a little SQL. The panel chimes in, explaining that when it comes to working in .NET and C# SQL is essential. 

Panelists

• Shawn Clabough

• Caleb Wells

Guest

• Wade Gausden

Sponsors

• Sustain Our Software

• React Round Up

• My JavaScript Story

• CacheFly

Links

• .NET 007: What We Know About LINQ

• .NET 003: Blazor with Daniel Roth

• .NET Conf 

• .NET Core 3.0 Released – Here’s The Goodies!

• Dapper In .NET Core – Part 1 – The What/Why/Who

• StackOverflow’s ORM goes Open Source 

• https://dotnetcoretutorials.com

• https://twitter.com/netCoreTutorial

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/dotNET_Podcast

Picks

Caleb Wells:

• Funny Joke Programming If Coding Headphones Focus T-Shirt 

Shawn Clabough:

• http://freakonomics.com/ 

Wade Gausden:

• Masters of Doom 

Special Guest: Wade Gausden.

On this week's Adventures in .NET, Charles Max Wood (Chuck) talks about the recent Twitter thread about 10x engineers. He goes through each of the points in the tweet and talks about each of them in turn. There are only two points he sort of agrees with, and believes the rest to be absolute garbage. One of the issues with this tweet is that it doesn’t define what a 10x engineer is.

Defining a 10x engineer is difficult because it is also impossible to measure a truly average engineer because there are many factors that play into measuring productivity. Chuck turns the discussion to what a 10x engineer is to him and how to find one. A 10x engineer is dependent on the organization that they are a part of, because they are not simply found, they are made.

When a 10x engineer is added to a team, the productivity of the entire team increases. Employers have to consider firstly what you need in your team and how a person would fit in. You want to avoid changing the entire culture of your organization. Consider also that a 10x engineer may be hired as a 2x engineer, but it is the employer that turns them into a 10x engineer.

Overall, Chuck believes these tweets are asinine because it’s impossible to measure what makes a 10x engineer in the first place, and hiring a person that fits the attributes in the list would be toxic to your company.

Panel

• Charles Max Wood

Sponsors

• The Freelancers' Show

• Elixir Mix

• My Angular Story

• CacheFly

Links

• 10x engineer Twitter thread

• What Really Makes a 10x Engineer?

Follow DevChat.tv on Facebook and Twitter

Picks

Charles Max Wood:

• Copyhackers.com

• Good to Great by Jim Collins

• Keto diet

• Podcast Movement

 In this week’s episode of Adventure in .NET the panel shares their experiences using LINQ or Language Integrated Query. They discuss the benefits of using LINQ  along with the struggles they have with it. They share some of their favorite tips and tricks for using LINQ. 

LINQ is something .NET developers use on a daily basis. The panel starts by giving a little background on LINQ. LINQ was introduced to the .NET framework 3.5 with the intent of providing a better way of dealing with data. The panel explains what they did before using LINQ and what it was like making the switch. 

LINQ has two different syntaxes, the query syntax, and the lambda syntax. The panel discusses the similarities between query syntax and SQL. They explain why they didn’t just use SQL. Because SQL and query were so similar, the panel both started by using query. They share different ways to get used to the query syntax and the lambda syntax. 

One benefit of using LING is that it is supported in all .NET languages and has been ported over to other languages such as PHP, JavaScript, and Typescript. The panel discusses using in it Angular Typescript and the similarities between it and C#. 

The panel reveals that there are a number of features in .NET that were built to support LINQ. Lambda expressions, anonymous type, and tuples are some examples of features that support LINQ. The panel defines these features and explains how they help you sort through collections of data. 

The panel considers why some programmers are turned off by LINQ. They suppose it is because of its foreign look and that it is not highly structured. Also, LINQ has a lot of syntactic sugar, doing a lot of stuff for you behind the scenes. The panel discusses ways LINQ simplifies workflow and shares tips for using LINQ to simply code. 

Programmers often complain that using LINQ to objects or LINQ to entities and chaining LINQ extensions is an improper use of LINQ.  The panel explains how using LINQ this way makes the code cleaner and more readable. The panel compares the readability of LINQ statements to SQL statements. They explain why LINQ is easier to read and understand.

The panel shares their tips and tricks for using LINQ statements and deferred executions. They discuss the possible use cases for using deferred executions. They also consider the downsides and gotchas to watch for when using deferred executions. 

LINQ to entity and the Entity framework are considered. The panel discusses the common complaints made about Entity. They address these complaints, explaining how LINQ to entity and the framework has improved. The panel suggests the use of LINQPad for LINQ statements to see the generated sequel statement. They explain what to watch out for when using LINQ pad this way. 

One struggle panel discusses is knowing when to use first or firstordefault. They share tips, things to look for when using either one of these in LINQ. First and single are compared, the panel explains why they use first more than single. 

The possibilities for extension methods in LINQ are considered. Along with using C# extension methods the panel discussing using custom extension methods. They share their favorite third party extension methods and explains how they have helped them simplify their code. 

While the panel is aware that many programmers are averse to mixing functional programming and object-oriented programming, the panel explains that there are a few functional programming concepts built into LINQ. The benefits of being able to use functional programming in C# is explained. 

The panel considers some of the hardest things to do in LINQ and share tips on how to better understand them. Select many and aggregate LINQ queries being to examples they share. The explain what powerful tools they can be. The panel ends the episode with some tips for improving performance when using LINQ

Panelists

• Shawn Clabough

• Caleb Wells

Sponsors

• Adventures in Blockchain

• My Ruby Story

• The Dev Rev

• CacheFly

Links

• https://entityframework-extensions.net/ 

• https://github.com/morelinq/MoreLINQ 

• Language Integrated Query (LINQ)

• https://en.wikipedia.org/wiki/Language_Integrated_Query

• https://www.tutorialsteacher.com/linq/linq-tutorials

• Expression Trees (C#)

• Supporting IAsyncEnumerable with LINQ

• Get Func-y: Delegates in .NET - Jeremy Clark

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/dotNET_Podcast

Picks

Caleb Wells:

• Plex

• PlayOn 

Shawn Clabough:

• https://www.linqpad.net/ 

 In this week’s episode of Adventure in .NET the panel shares their experiences using LINQ or Language Integrated Query. They discuss the benefits of using LINQ  along with the struggles they have with it. They share some of their favorite tips and tricks for using LINQ. 

LINQ is something .NET developers use on a daily basis. The panel starts by giving a little background on LINQ. LINQ was introduced to the .NET framework 3.5 with the intent of providing a better way of dealing with data. The panel explains what they did before using LINQ and what it was like making the switch. 

LINQ has two different syntaxes, the query syntax, and the lambda syntax. The panel discusses the similarities between query syntax and SQL. They explain why they didn’t just use SQL. Because SQL and query were so similar, the panel both started by using query. They share different ways to get used to the query syntax and the lambda syntax. 

One benefit of using LING is that it is supported in all .NET languages and has been ported over to other languages such as PHP, JavaScript, and Typescript. The panel discusses using in it Angular Typescript and the similarities between it and C#. 

The panel reveals that there are a number of features in .NET that were built to support LINQ. Lambda expressions, anonymous type, and tuples are some examples of features that support LINQ. The panel defines these features and explains how they help you sort through collections of data. 

The panel considers why some programmers are turned off by LINQ. They suppose it is because of its foreign look and that it is not highly structured. Also, LINQ has a lot of syntactic sugar, doing a lot of stuff for you behind the scenes. The panel discusses ways LINQ simplifies workflow and shares tips for using LINQ to simply code. 

Programmers often complain that using LINQ to objects or LINQ to entities and chaining LINQ extensions is an improper use of LINQ.  The panel explains how using LINQ this way makes the code cleaner and more readable. The panel compares the readability of LINQ statements to SQL statements. They explain why LINQ is easier to read and understand.

The panel shares their tips and tricks for using LINQ statements and deferred executions. They discuss the possible use cases for using deferred executions. They also consider the downsides and gotchas to watch for when using deferred executions. 

LINQ to entity and the Entity framework are considered. The panel discusses the common complaints made about Entity. They address these complaints, explaining how LINQ to entity and the framework has improved. The panel suggests the use of LINQPad for LINQ statements to see the generated sequel statement. They explain what to watch out for when using LINQ pad this way. 

One struggle panel discusses is knowing when to use first or firstordefault. They share tips, things to look for when using either one of these in LINQ. First and single are compared, the panel explains why they use first more than single. 

The possibilities for extension methods in LINQ are considered. Along with using C# extension methods the panel discussing using custom extension methods. They share their favorite third party extension methods and explains how they have helped them simplify their code. 

While the panel is aware that many programmers are averse to mixing functional programming and object-oriented programming, the panel explains that there are a few functional programming concepts built into LINQ. The benefits of being able to use functional programming in C# is explained. 

The panel considers some of the hardest things to do in LINQ and share tips on how to better understand them. Select many and aggregate LINQ queries being to examples they share. The explain what powerful tools they can be. The panel ends the episode with some tips for improving performance when using LINQ

Panelists

• Shawn Clabough

• Caleb Wells

Sponsors

• Adventures in Blockchain

• My Ruby Story

• The Dev Rev

• CacheFly

Links

• https://entityframework-extensions.net/ 

• https://github.com/morelinq/MoreLINQ 

• Language Integrated Query (LINQ)

• https://en.wikipedia.org/wiki/Language_Integrated_Query

• https://www.tutorialsteacher.com/linq/linq-tutorials

• Expression Trees (C#)

• Supporting IAsyncEnumerable with LINQ

• Get Func-y: Delegates in .NET - Jeremy Clark

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/dotNET_Podcast

Picks

Caleb Wells:

• Plex

• PlayOn 

Shawn Clabough:

• https://www.linqpad.net/ 

Episode Summary

In this week’s episode of Adventures in .NET the panel interviews Filip Ekberg, Microsoft MVP, about using async, await, and the new features in C# 8. They begin by discussing the evolution of running tasks and multithreading in async. Filip describes the evolution beginning with background workers, through task parallel libraries finally to async and await. The panel considers how managing tasks has been made almost too easy.  

Filip explains that there has been a drive to make everything asynchronous but explains that this approach doesn’t always make sense. The panel asks Filip when a developer should use async and await. If an application has a UI, Filip encourages the use of async and await and he outlines the benefits. He also explains that if someone wants to be a full-stack developer they need to understand async and await on both the serverside and clientside. 

The panel wonders what the most common async and await mistakes are in .NET. Filip shares a couple of the most common mistakes he sees. The first is deadlocking an application because of the inappropriate methods such as .result and .wait on tasks. The second is marking methods as async without running the await keyword. He explains what these mistakes do to your application and gives advice on avoiding these mistakes. 

The panel expresses past frustrations in making all methods especially tops methods when in ASP.NET. Filip gives the panel advice on making it asynchronous top to bottom and ways to handle those aggravating top methods. He also explains how to use the await keyword and state machines effectively.

Debugging in async is the next topic the panel considers. Filip explains why debugging is so tricky in asynchronous applications. He gives a few tips, his biggest piece of advice is to update Visual Studio and you should get more help in debugging than from older versions. 

The panel moves on to discuss C# 8. Filip explains that C# is his language, he loves it! He shares three new changes to the language features in C# 8. They made changes to how tuples work, pattern matching and null reference types. 

Tuples are the first change the panel considers. Filip explains what tuples are and what they do. Tuples allow you to represent a type without actually using that type. The panel considers how tuples have changed in C# 8, they are still position based but are more flexible in calling them. 

Next, the panel discusses null reference types. The control null reference types allow over nulls is considered. Filip shares some recommendations for using null reference types. The panel considers what might happen if someone were to use null reference types in an existing application. The wonder if it would have any benefit or if it would break the whole application. 

The final feature they discuss is pattern matching. Filip explains the benefit of using the new pattern matching with the new tuples feature in C# 8. The new pattern matching can be used to find tupple patterns, position patterns, and property patterns. 

Panelists

• Shawn Clabough

• Charles Max Wood

• Caleb Wells

Guest

• Filip Ekberg

Sponsors  

• Adventures in Blockchain

• Adventures in DevOps

• The Freelancers Show

• CacheFly

Links

• C# 8 and Beyond - Filip Ekberg 

• Back to Basics: Efficient Async and Await - Filip Ekberg 

• https://twitter.com/fekberg?lang=en

• https://www.filipekberg.se/

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/dotNET_Podcast

Picks

Charles Max Wood:

• RR 429: Mechanical Confidence with Adam Cuppy

• JSJ 392: The Murky Past and Misty Future of JavaScript with Douglas Crockford

• Dr. Mario World

Caleb Wells:

• Upgrade to the new Nintendo Switch 

Filip Ekberg:

• Final Fantasy VIII Remastered

• Final Fantasy VII Remake

Shawn Clabough:

• https://oz-code.com/ 

Special Guest: Filip Ekberg.

Episode Summary

In this episode of Adventures in .NET, James Montemagno, a PM in the developer division at Microsoft working with Xamarin shares with the panel all of the exciting things happening in the Xamarin world. Charles Max Wood invites listeners to check out James’s appearances on a different DevChatTV podcast, The iPhreaks Show. Charles expresses his excitement to see Xamarin from a .NET perspective. 

James starts the discussion by sharing how he got into Xamarin and .NET. He explains what he loves about .NET. James worked for Xamarin during the transition into Microsoft, he shares what it was like and how the unification of the two made their products even better. The panel discusses the changes in Microsoft’s practices over the past ten years, becoming more opensource friendly and less focused on selling products.

What is Xamarin, is the next thing the panel answers. James explains that Xamarin helps developers build native apps in C#. He goes on to explain how the versions of Xamarin change based on the platform, Android, iOS and tooling inside visual studio. 

The topic turns to how Xamarin runs. James explains that there is a common theme in Xamarin, flexibility. Choosing how Xamarin is run is up to the developer, who can use AOT (ahead of time) or JIT (just in time). Charles explains what AOT and JIT mean and how they affect application size and performance. James explains how Xamarin runs differently for Android and iOS. 

James introduces a brand new mode called Startup Tracing and explains how it can reduce the start-up time for your Xamarin apps by up to 60% by using a small trace of AOT. He shares the future goals for this mode and explains that it is free and can be used today.  

The next concern the panel has is about sharing code between different platforms and how this works with Xamarin. James explains that this problem is solved with Xamarin forms, Xamarin forms has everything a mobile app developer could want. In Xamarin forms developers can create pages to share cross-platform or simply build their whole app for all platforms. James even explains how a developer can make platform-specific adjustments to the code. 

James defines customer-driven development and explains how this allows them to create the best product for developers. The flexibility and capabilities in UI’s and controls allows developers to choose what their app looks like. Caleb asks about the built template components that allows the developer to architect the navigation in their applications. James explains one of the tools, Shell and how it helps you set up your navigation how you want it while handling all the messiness with minimal code. 

Charles asks James about library integration into Xamarin. James starts by sharing what comes in the box with Xamarin, 100% API coverage for both Android and iOS. How this works is, a team looks at the needs of developers and makes a list of the necessary, popular and desired libraries and creates API bindings for them. Libraries that don’t make that list can have a binding generated with Xamarins binding generator, which will include the necessary features needed to use the library. 

The panel changes the topic to the new Xamarin features that James is most excited for. James mentions a one-stop library called Xamarin essentials that will hold all the things a developer might need. He also includes Xaml hot reload for Xamarin forms, this feature will create a better level of productivity as it reloads around typos and mistakes allowing developers to stay in their workflow. The panel discusses the other benefits of a feature like this. Caleb Wells warns how addictive a good hot reload can be.

The episode ends with James giving advice and resources for getting into Xamarin. Charles praises the Microsoft documentation. Caleb gives an endorsement for Microsoft Learn. Charles invites listeners to suggest topics and guests at devchat.tv. 

Panelists

• Charles Max Wood

• Caleb Wells

Guest

• James Montemagno

Sponsors  

• Adventures in DevOps

• The Freelancers Show

• React Round Up

• CacheFly

Links

• https://montemagno.com/podcast-equipment-accessories-guide/ 

• https://devchat.tv/views-on-vue/vov-078-waxing-philosophical-with-christoffer-noring 

• www.mergeconflict.fm 

• www.nintendodispatch.com 

• www.xamarinpodcast.com 

• https://www.mw-embedded.com/product/gameboy-color-replacement-lcd-module/ 

• 096 iPS Xamarin and Wearables with James Montemagno 

• iPS 206 Build Special 1: Embeddinator 4000 with James Montemagno 

• 175 iPS Xamarin with James Montemagno 

• https://montemagno.com/podcast-equipment-accessories-guide/ 

• www.mergeconflict.fm 

• www.nintendodispatch.com 

• www.xamarinpodcast.com 

• https://dotnet.microsoft.com/apps/xamarin

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/dotNET_Podcast

Picks

Charles Max Wood:

• The Expanse

• The Black List

• The Amazing Race

Caleb Wells:

• Doom Patrol 

James Montemagno:

• The Bachelor 

• The Bachelor in Paradise

• Ozarks

• The Big Lebowski

• https://www.mw-embedded.com/product/gameboy-color-replacement-lcd-module/<

Sponsors

• CacheFly

Panel

• Charles Max Wood

• Shawn Clabough

• Caleb Wells

Joined by Special Guest: Mads Kristensen

Summary

Mads Kristensen, from Microsoft, joins the panel to discuss building extensions in visual studio. Mads shares his story of getting into building extensions. Mads gives recommendations when getting started building an extension. The panel discusses what are important things to understand when you are new to building extensions. 

Charles Max Wood asks about the capabilities of extensions. Mads gives best practices for building extensions. Why writing extensions is getting easier and the place of extension in Microsoft is considered by the panel. The panel discusses the versions of visual studios and how they affect extensions. Mads shares what he is working on right now.

Links

• 236 JSJ Interview with Mads Kristensen from Microsoft Ignite 

• Getting started writing Visual Studio extensions 

• Visual Studio 2015 Extensibility 

• Checklist for writing great Visual Studio extensions 

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/adventures_net

Picks

Charles Max Wood:

• Azure Functions

• Stranger Things Season 3

Shawn Clabough:

• https://slcnet.tech/

• https://www.dotvvm.com/

Caleb Wells:

• Xbox Live for PC

Mads Kristensen:

• https://hubitat.com/

Special Guest: Mads Kristensen.

Sponsors

• CacheFly

Panel

• Caleb Wells

• Shawn Clabough

Summary

In this very first episode of Adventures in .NET the panel starts by introducing themselves. The panel shares their journeys when they got started in programming and how they got into .NET. The panel considers the evolution of technology and how the modern path of a programmer has changed. They discuss what projects they are currently working on and what projects excite them in .NET. 

Links

• https://www.linkedin.com/in/calebcwells 

• https://twitter.com/wopr_dev

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/adventures_net

Picks

Caleb Wells:

• Enneagram

Shawn Clabough:

• WarGames

• https://www.dotnetconf.net/

Sponsors

• CacheFly

Panel

• Shawn Clabough

• Caleb Wells

Joined by Special Guest: Colby Tresness

Summary

Colby Tresness, from Microsoft, joins the panel to answer questions about azure functions. He starts by defining the two different types of azure functions. He overviews the different plans available and what they offer. The panel discusses the best use cases for azure functions and Colby shares what to avoid doing with azure functions. 

The panel asks Colby about cold start penalties and the security of functions. Colby explains what languages azure functions supports and how it is able to support so many different languages. The new trend of using azure storage for static websites is discussed. Colby talks about durable functions, a stateful function. 

Links

• https://code.visualstudio.com/docs/azure/deployment 

• https://azure.microsoft.com/en-us/blog/author/cotresne/

• https://github.com/ColbyTresness

• https://twitter.com/colbytresness?lang=en

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/adventures_net

Picks

Shawn Clabough:

• NPR Planet Money

Caleb Wells:

• Elder Scrolls Online

Colby Tresness:

• Dark

Special Guest: Colby Tresness.

Sponsors

• CacheFly

Panel

• Shawn Clabough

• Caleb Wells

Joined by Special Guest: Daniel Roth

Summary

Daniel Roth, from Microsoft, the ASP .NET team, joins the panel to discuss Blazor. Daniel starts by introducing Web Assembly and how this changed web development. Blazor allows full-stack development through .NET with C#. The panel asks Dan about Blazor's capabilities and future. Dan shares Blazor’s origin story. 

The panel compares Blazor to Silverlight and Dan compares the two and explains how Blazor is superior to Silverlight. Dan explains why developers are so excited for Blazor. The panel discusses the runtime Blazor uses and whether it is core only. The panel asks Dan about how to adopt Blazor into specific projects and how Blazor works under the hood. 

Links

• https://blazor.net

• NDC Oslo 2019: Blazor, a new framework for browser-based .NET apps - Steve Sanderson

• Telerik

• DevExpress

• Syncfusion

• Radzen

• https://github.com/AdrienTorris/awesome-blazor

• https://gitter.im/aspnet/blazor

• https://github.com/aspnet/AspNetCore/tree/master/src/Components

• ASP.NET Core and Blazor updates in .NET Core 3.0 Preview 7

• Blazor now in official preview!

• https://aka.ms/blazorworkshop

• https://devblogs.microsoft.com/aspnet/

• https://github.com/AdrienTorris/awesome-blazor

• Blazor, a new framework for browser-based .NET apps - Steve Sanderson 

• https://gitter.im/aspnet/blazor 

• https://github.com/danroth27 

• https://twitter.com/danroth27?lang=en

• https://www.facebook.com/Adventures-in-NET-373059030062837/

• https://twitter.com/adventures_net

Picks

Shawn Clabough:

• Merlin

Caleb Wells:

• Muse 2 headband 

Daniel Roth:

• Roblox 

Special Guest: Daniel Roth.