Adventures in .NET

In this episode of Adventures in .NET the panel shares some of the things they have been doing in their work. Caleb Wells starts by talking about unit testing. His team at work started implementing unit testing he got to do a lot of research for their project. He shares some of the unit testing frameworks he looked at and explains why he chose XUnit. Other tools he is using include MOQ, Bogus and Fluent Assertions. They discuss what these do and how they make unit testing easier.  Wai Liu tells Caleb all about GraphQL and why it is better than using a rest API. It is more efficient and cleaner. It is also easy to incorporate into an existing application. Wai also wants to discuss authentication. He explains that there is no need to create custom authentication solutions when there are so many great authentication tools built by people smarter than you. He recommends Firebase Auth by Google. The panel explains the difference between authentication and authorization. Panelists

• Wai Liu
• Caleb Wells
   

Sponsors

• CacheFly

____________________________________________________________ "The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is now available on Amazon. Get Your Copy Today! ____________________________________________________________   Links

• GraphQL-dotnet 
• NET Core 2: Why xUnit and not NUnit or MSTest 
• https://xunit.net/
• Quickstart 
• Bogus 
• Firebase Auth 
• https://github.com/graphql-do\
  tnet/graphql-dotnet 
• https://fluentassertions.com/ 
• https://www.ncrunch.net/ 
• www.linkedin.com/in/wai-liu
• https://twitter.com/WOPR_Dev
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

  Picks Caleb Well:

• Paw Patrol On a Roll 

Wai Liu:

• Amazon Prime Video X-ray Feature

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel discusses the tools and techniques they use to find their focus while developing. They begin by discussing their personal obstacles when trying to focus on their work. Some of the panelists suffer from ADD, ADHD, and OCD, they explain the challenges these problems bring to their work. They also discuss the flow state good focus can bring and what can be accomplished during that time of deep work.  The first tool they discuss that helps them focus is music. Music can be a distraction if it is the wrong music. They discuss the types of music that help them focus. The benefits of classical music, music without words and even rock music are considered by the panel.  Next, the panel discusses todo lists. There are many different todo list apps, the panel considers how to find the ones for you. Wai Liu advocates for the todo list and explains how he rates the completion of his todo list and evaluates it before creating his list for the next week. The panel discusses productivity apps and shares ideas of what would make a great productivity app.  They consider the merits of meditation. They all agree that meditation has many great benefits but is also quite difficult to master. Wai shares his experience at a meditation retreat. The panel discusses procrastination and distractions both at the work office and at the home office. They consider techniques and resources that help them focus.  Panelists

• Shawn Clabough
• Wai Liu
• Caleb Wells

Sponsors

• CacheFly

____________________________________________________________ "The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is now available on Amazon. Get Your Copy Today! ____________________________________________________________   Links

• https://en.wikipedia.org/wiki/Pomodoro_Technique 
• www.linkedin.com/in/wai-liu
• https://twitter.com/WOPR_Dev
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

  Picks Shawn Clabough:

• http://mtcb.pwop.com/ 
• Ice hockey

Caleb Well:

• https://www.calm.com/ 
• https://www.brain.fm/ 
• Deep Work 
• Indistractable 

Wai Liu:

• Nintendo Switch

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel discusses Shawn Clabough’s experience at Microsoft Ignite. The conference was held in Orlando, Florida and was huge. Shares what he learned at the conference and through talking with the important Microsoft people he got to meet.  Shawn shares what he learned about Live Share, Visual Studio Online and Serverside Blazor, including how they work and pricing. Wai and Shawn consider what this emphasis on collaboration means and how it will affect the industry. Shawn shares ways for developers to try these tools now. The announcements at MS Ignite are discussed. They discuss Azure stack and Azure Arc. Shawn explains what they are and the panel discusses their possibles uses.  The atmosphere of the conference is discussed; Shawn shares the best parts of the conference. The food was great and there was a lot included in the price of the ticket. The conference also rented out Universal Studios for a night. Shawn shares some of the fun things he got to try at Universal Studios. He says the best part was getting to meet all the important Microsoft people.  Panelists

• Shawn Clabough
• Wai Liu

Sponsors

• CacheFly

Links

• https://www.microsoft.com/en-us/ignite
• https://www.microsoft.com/en-us/build
• .NET 015: Live Share and VS Online with Jonathan Carter at MS Ignite
• .NET 014: At MS Ignite with Scott Hunter
• www.linkedin.com/in/wai-liu
• https://twitter.com/WOPR_Dev
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

  Picks Shawn Clabough:

• https://visualstudio.microsoft.com/services/visual-studio-online/ 

Wai Liu:

• https://www.kiva.org/

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel records live at Microsoft Ignite and are joined by Jonathan Carter from Microsoft. Jonathan and the panel talk all about Live View and Visual Studio Online. They start by introducing Live Share, real-time collaboration specifically tailored to developers.  Jonathan explains why Live View is so special and how it differs from document collaboration. In order to work on a project in Live View you must first be invited, Jonathan explains how the set up is a simple as clicking on a link. With Live View, each developer in the collaboration can work in their customized environment. Jonathan explains that Live View is an end to end collaboration, including builds and debugging sessions.  Live View is not screen sharing, developers can work in multiple files on the same project and up to 30 developers can work on one project at a time. Security is addressed and Jonathan explains how Live share protects your code. The panel is impressed and considers ways they can use Live Share in their work. Jonathan shares use cases that Microsoft has seen and shares the benefits experienced by using Live Share.  Moving on the panel discusses Visual Studio Online. Jonathan explains how it works and shares what they have planned for it in the future. He explains how VS Online could irradicate setup by automatically meet the needs and personalizing environments. Jonathan shares use cases and the panel considers how they can use it in their own work. The panel wonders at it capabilities and limitations. Jonathan explains that it for not VS Online only works in Linux based environments but they are working on including other operating systems. The episode ends with a discussion of IntelliCode, a product Jonathan is working on combining AI and developer tools.  Panelists

• Shawn Clabough
• Charles Max Wood

Guest:

• Jonathan Carter

Sponsors

• CacheFly

Links

• https://www.microsoft.com/en-us/ignite
• aka.ms/podcastsweepstakes
• www.linkedin.com/in/wai-liu
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Special Guest: Jonathan Carter.

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

"The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is available on Amazon. Get your copy here today only for $2.99!

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET Shawn Clabough joins Scott Hunter at MS Ignite to talk about .NET Core 3.0 and C#8. Scott starts by explaining what the changes in C# 8.0 means to .NET. They discuss nullable reference types,  GRPCs, usings in blocks and side by side support. Shawn shares his experience with pattern matching. Scott explains why they no longer backport to older versions of .NET. Scott shares examples of all the apps they broke in the past by backporting changes made in later versions of .NET. Shawn admires their desire to not cause pain to developers by backporting breaking changes. Scott explains why he would choose .NET Core over the .NET Framework. He describes the whats new in side by side and what that could mean for developers  Getting a little sidetracked, Scott clears up any confusion about Blazor Server-side and Blazor Client-side. He explains that he has read and heard about people waiting to use Blazor Client-side because Blazor Server-side is not ready for use. Blazor Server-side is a wonderful and powerful tool, Scott tells listeners. He shares the use cases where you would want to use server-side and client-side.  After getting back on track, Scott and Shawn discuss WPF in WinForms. Scott explains the benefits of moving WPF apps to .NET Core. They discuss ML.net and Microsoft’s goals with AI. The meaning and uses of microservices are considered. They finish the episode by discussing .NET 5.0 and what they are planning.  Panelists

• Shawn Clabough

Guest:

• Scott Hunter

Sponsors

• CacheFly

Links

• https://www.microsoft.com/en-us/ignite
• https://dotnet.microsoft.com/apps/machinelearning-ai
• https://try.dot.net/
• www.linkedin.com/in/wai-liu
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Picks Shawn Clabough:

• aka.ms/podcastsweepstakes

Special Guest: Scott Hunter.

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel interviews Geovanny Alzate Sandoval, the creator of Simmy. Geovanny tells the panel all about Simmy, Poly, and chaos engineering. After defining each of these terms, the panel asks Geovanny questions about how they work. Chaos engineering intentionally breaks things to find weaknesses in systems, Simmy simulates those breaks and Poly helps create resilient systems. Before injecting chaos into your system, Geovanny has two suggestions. First, implement your resilience strategy. Second, have a good monitoring system in place to help you observe the chaos. He shares resources for those wanting to get started with Simmy and chaos engineering.  Simmy offers three different policies, fault, latency and behavior. Geovanny shares examples of each of these policies and explains what you are hoping to break and fix with each. He explains how Simmy can be used with an azure app and considers the possibilities of that use case Simmy currently gets in your system through Poly but they are working on a way to change that. He shares their plans for Simmy.    Panelists

• Shawn Clabough
• Caleb Wells

Guest

• Geovanny Alzate Sandoval

Sponsors

• Dev Ed Podcast
• Ruby Rogues
• Sustain Our Software
• CacheFly

________________________________________________________________________________________________________________________ "The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood will be out on November 20th on Amazon.  Get your copy on that date only for $1. ________________________________________________________________________________________________________________________ Links

• Simmy, the monkey for making chaos 
• https://github.com/Polly-Contrib/Simmy 
• Simmy and Azure App Configuration 
• Simmy Chaos Engine for .NET – Part 1, Injecting Faults 
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Picks Caleb Wells:

• https://www.dekudeals.com/

Geovanny Alzate Sandoval:

• https://www.hbo.com/westworld 

Shawn Clabough:

•  https://adaptivecards.io/ 
• http://www.adaptivecardsblazor.com/ 

Special Guest: Geovanny Alzate Sandoval.

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel interviews Phillip Carter. Phillip works on the .NET team. His primary focus is F# and F# tooling. Phillip starts off by explaining that F# is a functional programming language, whereas C# is an object-oriented language. Phillip explains how F# is a nice way for those who want to do functional programming to do so with a full ecosystem and quality tools and libraries.  Phillip explains how F# is used in .NET. Some prefer to use only F# but the major mix and match F# and C#. He shares projects he has done mixing and matching F# and C#, explaining how he did and the other methods used to use both F# and C#.  The panel discusses the popularity of F# and where it is most well known. Phillip shares the two biggest sites where F# sharp is used are Jet and Walmart e-commerce, their backends are build using an F# microservice. He explains that a lot of financial institutions use F# in their backends as it is good for number crunching. The panel considers the growth of F# since .NET Core 2.0 was released. After .NET Core 2.0 was released F# usage spiked, F# microservices and open source projects became much more common. The panel asks Phillip about what Blazor means for F#. He explains that in the past, some people are really into Fable. This tool takes F# syntax trees into JavaScript syntax trees. Currently, the web assembly is starting to heat up now that Blazor is here. F# can plug directly into the Blazor runtime making it a pretty viable alternative.  The panel considers the mental hurdles required when switching from C# to F#. Phillip explains how that switch may be easier for some than for others. Using an example of building a web service, Phillip explains how someone approaches a process or a problem will determine how easily someone can transition from C# to F#. He elaborates, explaining that if a developer is really used to object-oriented programming and it’s patterns it may be more difficult to move to F#. The panel shares some of its views on F#, wondering if it isn’t easier to learn for those who are new to programming. Phillip considers their views and explaining that even though they can’t prove it they have also seen this possibility. At the Ignite conference, they are coming out with a preview Jupiter Notebook tooling, putting C# and F# on top and integrating it into the Jupiter ecosystem. Phillip admits they have been wondering if they might not be able to reach the non or secondary programmers more easily with F#. F# may be more familiar to those who only have a simple background in Python they picked up in college. He explains how overwhelming C# can be to someone who has never seen anything like it before.   Phillip compares the syntax of C# and F#, explaining that they are very different. F# is more similar to Python than to C#. F# is white space significant and uses type inferences. He explains how these differences might trip up someone who is familiar with C#. C# and F# have a few similarities like you can still dot into something just like in C#.   The panel wonders what kind of cooperation is seen between the F# and C# teams at Microsoft. Phillip explains that they work very closely and sharing a few examples. He worked on nullable reference types in C# 8.0. He explains that they have a mindset, they are all Microsoft in the end and what C# and F# to interoperate as best they can.  F# is currently on version 4.7, which was released with C# 8.0. He shares some of the changes made to F# with this latest version. Including, core library fixes, performance fixes and the cleaning up of little syntactical quirks. He explains that is a culmination of a lot of minor changes to improve the language. Phillip shares what’s coming in F# 5.0 which will hopefully be released with the .NET 5.0 release.  The episode ends as Phillip shares some resources for getting started with F#. He encourages everyone to give it a try. He promises that even if you decide its not for you, it will help you see your code in new ways.  Panelists

• Shawn Clabough
• Wade Gausden
• Wai Liu

Guest

• Phillip Carter

Sponsors

• React Native Radio
• Adventures in Angular
• Adventures in Blockchain
• CacheFly

Links

• https://dotnet.microsoft.com/languages/fsharp
• https://fsharpforfunandprofit.com/
• https://www.microsoft.com/en-us/ignite
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Picks Wai Liu:

• Ninety7 Loft - google home battery base

Wade Gausden:

• Timsort — the fastest sorting algorithm you’ve never heard of 

Phillip Carter:

• http://themlbook.com/ 

Shawn Clabough:

• https://codeblog.jonskeet.uk 

 Special Guest: Phillip Carter.

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this episode of Adventures in .NET the panel interviews Patrick Smacchia who is known for his static analyzer, NDepend. The panel discusses NDepend, Patrick explains a bit about what is and how it works along with his history in .NET. Patrick is here to explains SOLID, an acronym introduced by Robert C. Martin outlining principles for object-oriented programming.  These principles teach programmers to use object-oriented programming correctly. The panel considers what can go wrong when object-oriented programming is misused. They also explain that the most important thing when it comes to SOLID is to try your best, it is impossible to be perfect in anything. Patrick explains that when your code is SOLID is will be easily testable and maintainable.  The five principles are Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Of all the principles, Single Responsibility is unique. Patrick explains that this principle is all about organization and advises developers to be very careful when using this principle in your domain. The domain is where it is most important to have SOLID code and it needs to be 100% covered by testing. The panel shares that this is the principle that they try the hardest to follow.   The definition given by Patrick for Single Responsibility is that a class should have a single responsibility or a class should have only one reason to change. Patrick warns the listeners that this is a very complex concept that is difficult to explain. The panel explains that Single Responsibility is a way to accomplish a separation of concern. The panel outlines the benefits of following this principle while Patrick shares some examples and walk the listeners implementing this principle.  The next principle is Open-Closed. Patrick’s definition of this principle is modules should be open for extension but closed for modification. He and the panel dive deeper into what this means. He advises developers when designing a class to be very careful when choosing the point of variation and make sure you don’t change the code in your base class. Caleb shares the problems they experienced in one of his recent projects when this principle was not followed. Patrick explains why the solution is more often the interface rather than the base class.  Moving on to the next principle, the Liskov substitution. Patrick explains how this principle using the example of the ibird. The Liskov substitution principle is that objects in a program should be replaceable so that you can’t tell the difference. In the ibird example, you can not replace the ibird with any bird because if the ibird can fly but the replacement bird is an ostrich it cannot perform the necessary functions. Patrick explains how ilists are in opposition to the Liskov principle.   Next is the Interface Segregation Principle. Patrick explains how this relates to the Single Responsibility Principle. He also discusses how the Liskov Substitution and the Interface Segregation are two sides of the same coin when it comes to designing interfaces. The Interface Segregation explains that many smaller client-specific interfaces are better that one large interface with everything on it.  The final principle is Dependency Inversion. Patrick explains that this principle does not help you design your interface, it helps you organize dependencies into your code structure.   This principle advises developers to depend on abstractions. He explains how this principle relates to dependency injection. The panel considers the damage dependencies can cause in a codebase if improperly used. Patrick explains when a developer will want to use abstractions and when to use classes. He explains that these 5 principles will become natural and feel like common sense as developers gain experience. Switching gears, the panel moves on to discuss a blogpost Patrick wrote explaining 4 predictions he had for the future of .NET. He wrote the article because of the announcement that .NET core will become .NET 5. The future of .NET has a great impact on NDepend and Patrick wanted to give some perspective to the changes and how they might affect his company.   His first prediction is that .NET standards won’t evolve much. Patrick explains that the purpose of .NET Standards was to support all the .NET flavors and with only .NET to support that job will become much simpler. He also speculates on the reasons for Microsoft wanting only one .NET. Some of the reasons he lists are that Microsoft does not have an endless workforce and .NET core is open source and multiplatform.  Patrick’s second prediction greatly impacts NDepend. His prediction is that Visual Studios will run on .NET 5, explaining why he is so sure that they will switch Visual Studios over to .NET 5. Patrick believes that it may take a while for the switch to happen. The panel considers the future of Windows.  The third prediction Patrick makes is that .NET will propose a cross-platform UI framework. Microsoft did a poll asking developers about the need for a cross-platform UI framework. The panel speculates how this framework will happen. Patrick wonders at the possibility of WPF. The panel brings up the final prediction, that Blazor has a bright future, and wonder if Blazor could become that cross-platform UI framework.   Panelists

• Shawn Clabough
• Caleb Wells

Guest

• Patrick Smacchia

Sponsors

• My Ruby Story
• React Native Radio
• Adventures in Angular
• CacheFly

Links

• www.ndepend.com 
• SOLID 
• 4 Predictions for the Future of .NET 
•  Satya Nadella reveals why Windows may not be the future of Microsoft’s business
• .NET 003: Blazor with Daniel Roth
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Picks Caleb Wells:

• https://www.packtpub.com/free-learning 

Shawn Clabough:

• https://conemu.github.io/ 

Special Guest: Patrick Smacchia .

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.

In this week’s episode of Adventures in .NET the panel is joined by Wai Liu, the new panelist, and Jason Bock, the special guest. Wai shares a bit about himself, currently, he works as a PM from Australia. His focus lately has been on Azure and .NET Core. Jason Bock introduces himself next, he is a practice lead for application development in .NET. He is a writer and a speaker, often about the new features of C#. The panel interviews Jason about the new features found in C# 8.0. The first thing developers should know about C# 8.0 is that it is no longer tied to .NET Framework. Jason explains that everything is slowly shifting to .NET Core and developers can only enjoy all the C# 8.0 features with .NET Core 3. He lists that some of the features can be used with .NET Framework.  The panel discusses migration to .NET Core from .NET Framework. Jason explains that it is not a question of if we should migrate but when should we migrate. Not only does .NET Core have better capabilities and speed but Microsoft is focussing all their future efforts in .NET core. Jason invites everyone to think about switching over and start making a plan.  The panel considers how hard it will be to move over large applications into .NET Core. Jason explains that since Microsoft has many applications in .NET framework they are in the same boat as other large enterprises. So, support for .NET Framework 4.8 will continue to be supported. The panel considers their current projects and how migrating could affect them.  Moving on to the new features of C# 8.0, the panel considers the two most exciting new features, default interface members and nullable reference types. They start by discussing nullable reference types. Nullable reference types allow developers to annotate types in parameters and properties and say that they are nullable.  The panel discusses the opt-in function of this feature and why that is necessary at this stage of its release. Jason explains how this all works and the two main purposes for nullable reference types. First, it is trying to reduce the number of null references developers get. Second, it allows developers to try expressing intent.  The panel shares their excitement to give nullable reference types a try. They also warn developers that they may want to run away when they first turn it on. Jason advises developers to turn it on in new projects, but for large projects, he advises developers to turn it on a profile basis. He explains that Microsoft is just getting started with nullable reference types and will continue to make changes all the way to .NET 5.0. Moving on to discuss default interface members, Jason predicts that default interface members will see a lot of abuse. The panel expresses their discomfort with the feature as it is a new way of using an interface. Jason explains the intent of this feature is to provide a way for developers to define an interface where some of the members have implementations. It is commonly referred to as default interface methods as most examples are with methods. The goal of default interface members is to improve versioning with interfaces. Jason explains that there are many possibilities for this feature and goes over some of them with the panel.  Jason explains that the difference between an interface and an abstract class is, an abstract class can have constructors and state whereas an interface cannot. The panel considers how default interface members could be considered normal practice in the future. Jason explains that there is still a lot of uncertainty around when to use them and when not to, it will take some time for default interface members to find their place. The other features discussed are the enhancements made to pattern matching, asynchronous streaming, enhancements of the using, ranges and indices. They explain briefly what each of these features does and how they will improve the .NET experience.  Panelists

• Shawn Clabough
• Caleb Wells
• Wai Liu

Guest

• Jason Bock

Sponsors

• Adventures in DevOps
• Views on Vue
• My Ruby Story
• CacheFly

Links

• Eliminating Nulls in C# 
• What's new in C# 8.0 
• https://github.com/JasonBock/Rocks 
• What's new in C# 8 - Part 1 
• What's new in C# 8 - Part 2 
• http://reactivex.io/ 
• http://jasonbock.net 
• http://github.com/jasonbock 
• https://www.facebook.com/Adventures-in-NET-373059030062837/
• https://twitter.com/dotNET_Podcast

Picks Caleb Wells:

• Prodigal Son 

Shawn Clabough:

• Blazor Asteroids 

Jason Bock:

• The Making of Alien

Wai Liu:

• Eleanor Oliphant Is Completely Fine: A Novel

Special Guest: Jason Bock.

Support this podcast at — https://redcircle.com/adventures-in-net/donations

Advertising Inquiries: https://redcircle.com/brands

Privacy & Opt-Out: https://redcircle.com/privacy

Become a supporter of this podcast: https://www.spreaker.com/podcast/adventures-in-net--6102015/support.