<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Welcome to TheSharperDev on TheSharperDev</title>
    <link>https://thesharperdev.com/</link>
    <description>Recent content in Welcome to TheSharperDev on thesharperdev.com</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Thu, 22 May 2025 05:00:00 -0500</lastBuildDate>
    
    <atom:link href="https://thesharperdev.com/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Introducing My Giraffe F# WebApp Template</title>
      <link>https://thesharperdev.com/posts/giraffe-web-app-template/</link>
      <pubDate>Thu, 22 May 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/giraffe-web-app-template/</guid>
      <description>
      
      A template to help you get started with a F# web app
      
      </description>
    </item>
    <item>
      <title>Using the FSharp.Compiler.Service to Compile a fsproj</title>
      <link>https://thesharperdev.com/posts/using-fsharp-compiler-service/</link>
      <pubDate>Tue, 11 Mar 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/using-fsharp-compiler-service/</guid>
      <description>
      
      Details on how to integrate with the FSharp.Compiler.Service
      
      </description>
    </item>
    <item>
      <title>How to Run a WebAssembly Program in F#</title>
      <link>https://thesharperdev.com/posts/brief-overview-of-webassembly/</link>
      <pubDate>Tue, 11 Feb 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/brief-overview-of-webassembly/</guid>
      <description>
      
      How to get started with web assembly in F#
      
      </description>
    </item>
    <item>
      <title>A Brief Overview of WebAssembly</title>
      <link>https://thesharperdev.com/posts/brief-overview-of-webassembly/</link>
      <pubDate>Fri, 31 Jan 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/brief-overview-of-webassembly/</guid>
      <description>
      
      A gentle introduction to web assembly
      
      </description>
    </item>
    <item>
      <title>How To Turn Off Framework Tests in a CI Action</title>
      <link>https://thesharperdev.com/posts/how-to-turn-off-framework-tests-in-ci-action/</link>
      <pubDate>Thu, 23 Jan 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/how-to-turn-off-framework-tests-in-ci-action/</guid>
      <description>
      
      
      
      </description>
    </item>
    <item>
      <title>How Different C# Data Structures Serialize to Json</title>
      <link>https://thesharperdev.com/posts/how-different-csharp-data-structures-serialize-json/</link>
      <pubDate>Sat, 11 Jan 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/how-different-csharp-data-structures-serialize-json/</guid>
      <description>
      
      
      
      </description>
    </item>
    <item>
      <title>Create and Populate an Object Via Reflection In C#</title>
      <link>https://thesharperdev.com/posts/create-populate-objects-via-reflection-in-csharp/</link>
      <pubDate>Fri, 10 Jan 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/create-populate-objects-via-reflection-in-csharp/</guid>
      <description>
      
      Some strategies for building objects via reflection.
      
      </description>
    </item>
    <item>
      <title>Introducing Ferris.Json Nuget Package</title>
      <link>https://thesharperdev.com/posts/ferris-json-nuget-package/</link>
      <pubDate>Sat, 04 Jan 2025 05:00:00 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/ferris-json-nuget-package/</guid>
      <description>
      
      My latest project is a new nuget library to support json serialization/deserialization.
      
      </description>
    </item>
    <item>
      <title>Deploy A Giraffe App to Fly.io</title>
      <link>https://thesharperdev.com/posts/deploy-giraffe-app-fly-io/</link>
      <pubDate>Wed, 16 Feb 2022 05:24:33 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/deploy-giraffe-app-fly-io/</guid>
      <description>
      
      The steps needed to deploy a giraffe application to fly.io
      
      </description>
    </item>
    <item>
      <title>Play Audio - Fable/F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-fable-play-audio/</link>
      <pubDate>Sat, 29 Jan 2022 18:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-fable-play-audio/</guid>
      <description>
      
      Demonstrating how to play an audio clip in Fable
      
      </description>
    </item>
    <item>
      <title>Set Timeout Function - Fable/F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-fable-settimeout/</link>
      <pubDate>Tue, 18 Jan 2022 18:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-fable-settimeout/</guid>
      <description>
      
      Demonstrating how to call setTimeout in Fable
      
      </description>
    </item>
    <item>
      <title>Keyup Event Listener - Fable/F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-fable-keyup-event-listener/</link>
      <pubDate>Mon, 17 Jan 2022 16:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-fable-keyup-event-listener/</guid>
      <description>
      
      Demonstrating how to create a keyup event listener in Fable
      
      </description>
    </item>
    <item>
      <title>Introduction to Functions - F#</title>
      <link>https://thesharperdev.com/posts/intro-fsharp-functions/</link>
      <pubDate>Fri, 15 Oct 2021 05:24:33 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/intro-fsharp-functions/</guid>
      <description>
      
      How do you define a F# function? What&#39;s the difference between a method and a function? Lets find out.
      
      </description>
    </item>
    <item>
      <title>Seq.choose - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-choose/</link>
      <pubDate>Thu, 14 Oct 2021 05:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-choose/</guid>
      <description>
      
      Seq.choose filters and unwraps Option types
      
      </description>
    </item>
    <item>
      <title>Seq.cast - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-cast/</link>
      <pubDate>Wed, 13 Oct 2021 04:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-cast/</guid>
      <description>
      
      Seq.cast helps supports automatic type conversions for loosely-typed collections.
      
      </description>
    </item>
    <item>
      <title>Seq.cache - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-cache/</link>
      <pubDate>Tue, 12 Oct 2021 04:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-cache/</guid>
      <description>
      
      Seq.cache helps improve performance by avoiding regeneration for costly sequences.
      
      </description>
    </item>
    <item>
      <title>Seq.averageBy - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-averageby/</link>
      <pubDate>Mon, 11 Oct 2021 12:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-averageby/</guid>
      <description>
      
      Seq.averageBy extracts a value from a complex object to perform an average.
      
      </description>
    </item>
    <item>
      <title>Seq.average - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-average/</link>
      <pubDate>Sun, 10 Oct 2021 12:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-average/</guid>
      <description>
      
      Seq.average computes the average of anything in the sequence.
      
      </description>
    </item>
    <item>
      <title>Seq.append - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-append/</link>
      <pubDate>Sat, 09 Oct 2021 12:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-append/</guid>
      <description>
      
      Seq.append concats two sequences together.
      
      </description>
    </item>
    <item>
      <title>Seq.allPairs - F#</title>
      <link>https://thesharperdev.com/snippets/fsharp-seq-allpairs/</link>
      <pubDate>Fri, 08 Oct 2021 16:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/snippets/fsharp-seq-allpairs/</guid>
      <description>
      
      Seq.allPairs pairs elements from each sequence to create a new sequence.
      
      </description>
    </item>
    <item>
      <title>Memoization in F#</title>
      <link>https://thesharperdev.com/posts/fsharp-memoization/</link>
      <pubDate>Fri, 08 Oct 2021 06:29:54 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/fsharp-memoization/</guid>
      <description>
      
      Sometimes functions are asked recompute the same value over and over again. Why do all that extra work?
Memoization is h...
      
      </description>
    </item>
    <item>
      <title>Fibonacci in F# - Five Ways</title>
      <link>https://thesharperdev.com/posts/fsharp-fibonacci-five-ways/</link>
      <pubDate>Thu, 30 Sep 2021 16:14:34 -0500</pubDate>
      
      <guid>https://thesharperdev.com/posts/fsharp-fibonacci-five-ways/</guid>
      <description>
      
      Recrusion is cool! And Fibonacci is a standard algorithm to examine when exploring recursion.
Here are five ways to gene...
      
      </description>
    </item>
    <item>
      <title>Supervised v. Unsupervised v. Reinforcement Learning: An Introduction</title>
      <link>https://thesharperdev.com/supervised-v-unsupervised-v-reinforcement-learning-an-introduction/</link>
      <pubDate>Mon, 18 May 2020 00:27:47 +0000</pubDate>
      
      <guid>https://thesharperdev.com/supervised-v-unsupervised-v-reinforcement-learning-an-introduction/</guid>
      <description>
      
      Machine Learning has changed our world. It will continue to change our world. Lets walk through and talk about the 3 main categories of the Machine Learning fields.
      
      </description>
    </item>
    <item>
      <title>Optimizing our Perfect Tic-Tac-Toe Bot</title>
      <link>https://thesharperdev.com/optimizing-our-perfect-tic-tac-toe-bot/</link>
      <pubDate>Sun, 10 May 2020 18:20:36 +0000</pubDate>
      
      <guid>https://thesharperdev.com/optimizing-our-perfect-tic-tac-toe-bot/</guid>
      <description>
      
      Searching everything is slow. Luckily there are a number of optimizations we can apply in order to speed up our searching. In this article we&#39;ll look into alpha-beta pruning and significantly speed up our Tic-Tac-Toe bot!
      
      </description>
    </item>
    <item>
      <title>Coding A Perfect Tic-Tac-Toe Bot!</title>
      <link>https://thesharperdev.com/coding-the-perfect-tic-tac-toe-bot/</link>
      <pubDate>Sun, 03 May 2020 19:11:33 +0000</pubDate>
      
      <guid>https://thesharperdev.com/coding-the-perfect-tic-tac-toe-bot/</guid>
      <description>
      
      Tic-Tac-Toe is a simple game to demonstrate the power of searching. By the end of this article we&#39;ll create a python bot that will never lose a game of Tic-Tac-Toe!
      
      </description>
    </item>
    <item>
      <title>Implementing Minimax Tree Search</title>
      <link>https://thesharperdev.com/implementing-minimax-tree-search/</link>
      <pubDate>Sun, 26 Apr 2020 00:30:12 +0000</pubDate>
      
      <guid>https://thesharperdev.com/implementing-minimax-tree-search/</guid>
      <description>
      
      Games allow for easy testing of a program&#39;s intelligence. Lets implement a simple search algorithm to create a tic-tac-toe bot that never loses. Tic-tac-toe is a simple game, but MiniMax is an affect way to cut down search trees in a variety of situations.
      
      </description>
    </item>
    <item>
      <title>Getting Started with Machine Learning Using Keras</title>
      <link>https://thesharperdev.com/getting-started-with-machine-learning-using-keras/</link>
      <pubDate>Sat, 18 Apr 2020 19:31:00 +0000</pubDate>
      
      <guid>https://thesharperdev.com/getting-started-with-machine-learning-using-keras/</guid>
      <description>
      
      Keras is one of the go to choices for Machine Learning in Python, especially Deep Machine Learning. Lets write our first application in Keras to demonstrate how easy and how useful this library is.
      
      </description>
    </item>
    <item>
      <title>Build Your First Neural Network: Part 3</title>
      <link>https://thesharperdev.com/build-your-first-neural-network-part-3/</link>
      <pubDate>Sun, 12 Apr 2020 18:55:51 +0000</pubDate>
      
      <guid>https://thesharperdev.com/build-your-first-neural-network-part-3/</guid>
      <description>
      
      Lets solve an actual problem with your neural network. It will learn to recognize handwritten digits. It&#39;s a class intro to Machine Learning. But always useful to help understand what&#39;s really going on with Machine Learning and how it works.
      
      </description>
    </item>
    <item>
      <title>Useful NumPy Operations for Machine Learning</title>
      <link>https://thesharperdev.com/useful-numpy-operations-for-machine-learning/</link>
      <pubDate>Mon, 06 Apr 2020 00:45:04 +0000</pubDate>
      
      <guid>https://thesharperdev.com/useful-numpy-operations-for-machine-learning/</guid>
      <description>
      
      Python is the best way to learn Machine Learning. NumPy is one of the most useful libaries in Python. Lets take a look at NumPy and how understanding it can help us in our understanding of Machine Learning.
      
      </description>
    </item>
    <item>
      <title>Build Your First Neural Network: Part 2</title>
      <link>https://thesharperdev.com/build-your-first-neural-network-part-2/</link>
      <pubDate>Sun, 29 Mar 2020 19:39:27 +0000</pubDate>
      
      <guid>https://thesharperdev.com/build-your-first-neural-network-part-2/</guid>
      <description>
      
      Lets continue building on our first neural network. We&#39;ll introduce more of the math behind a neural network and demonstrate what makes a neural network learn.
      
      </description>
    </item>
    <item>
      <title>Build Your First Neural Network: Part 1</title>
      <link>https://thesharperdev.com/build-your-first-neural-network/</link>
      <pubDate>Tue, 24 Mar 2020 01:11:41 +0000</pubDate>
      
      <guid>https://thesharperdev.com/build-your-first-neural-network/</guid>
      <description>
      
      Machine Learning is transforming our world. It&#39;s a topic that every programmer, every person, should be familiar with. Lets build our first neural network for a first hand experience with this technology.
      
      </description>
    </item>
    <item>
      <title>Hope in the Midst of a Virus</title>
      <link>https://thesharperdev.com/hope-in-the-midst-of-a-virus/</link>
      <pubDate>Sun, 15 Mar 2020 19:03:27 +0000</pubDate>
      
      <guid>https://thesharperdev.com/hope-in-the-midst-of-a-virus/</guid>
      <description>
      
      Coronavirus has impacted our world. Shutdown, economic depressions, fear. Thankfully there&#39;s someone we can rely on that&#39;s bigger than any virus could ever be.
      
      </description>
    </item>
    <item>
      <title>Unit Testing Giraffe&#39;s HttpHandlers in F#</title>
      <link>https://thesharperdev.com/one-strategy-to-unit-test-giraffe-httphandlers-in-fsharp/</link>
      <pubDate>Sun, 08 Mar 2020 19:11:29 +0000</pubDate>
      
      <guid>https://thesharperdev.com/one-strategy-to-unit-test-giraffe-httphandlers-in-fsharp/</guid>
      <description>
      
      Giraffe is an F# ASP.NET Core web framework. It has quirks and patterns that I&#39;ve never encountered before in C# or web programming. The HttpHandler is one of the patterns new to me. Lets take a look at one way to unit test these handlers to ensure our application is working as expected.
      
      </description>
    </item>
    <item>
      <title>Examples Using HttpClient in F#</title>
      <link>https://thesharperdev.com/examples-using-httpclient-in-fsharp/</link>
      <pubDate>Sat, 29 Feb 2020 21:07:23 +0000</pubDate>
      
      <guid>https://thesharperdev.com/examples-using-httpclient-in-fsharp/</guid>
      <description>
      
      The HttpClient is the standard way to make web requests in .NET. Because F# is a functional language, it&#39;s usage is different than what you&#39;d find in C#. Here are some examples of how to use the HttpClient in F#.
      
      </description>
    </item>
    <item>
      <title>Thoughts on How I Embrace and Deal With Reality</title>
      <link>https://thesharperdev.com/thoughts-on-how-i-embrace-and-deal-with-reality/</link>
      <pubDate>Sun, 23 Feb 2020 23:47:47 +0000</pubDate>
      
      <guid>https://thesharperdev.com/thoughts-on-how-i-embrace-and-deal-with-reality/</guid>
      <description>
      
      We all try to escape or avoid reality. But until we face it, we&#39;ll never grow. We not only need to face it, but embrace it. So many of our errors in life come from not properly understanding or avoiding reality. How can I get better at it?
      
      </description>
    </item>
    <item>
      <title>F#’s MailboxProcessor</title>
      <link>https://thesharperdev.com/fsharps-mailboxprocessor/</link>
      <pubDate>Sun, 16 Feb 2020 02:28:48 +0000</pubDate>
      
      <guid>https://thesharperdev.com/fsharps-mailboxprocessor/</guid>
      <description>
      
      State is the root of a lot of problems in a multi threaded environment. One of F# solves this problem is by it&#39;s MailboxProcessor. It&#39;s a technique that allows for communication in a way that avoids the inherent problems of storing and sharing state.
      
      </description>
    </item>
    <item>
      <title>Exploring the Elmish Todo App</title>
      <link>https://thesharperdev.com/exploring-the-elmish-todo-app/</link>
      <pubDate>Mon, 10 Feb 2020 02:35:35 +0000</pubDate>
      
      <guid>https://thesharperdev.com/exploring-the-elmish-todo-app/</guid>
      <description>
      
      Elmish is a great UI building language. The todoapp is one of the best ways to see a UI language in action. Lets dive into the Elmish todo app and see what we can learn.
      
      </description>
    </item>
    <item>
      <title>C#’s WhenAll and Exception Handling</title>
      <link>https://thesharperdev.com/csharps-whenall-and-exception-handling/</link>
      <pubDate>Sun, 02 Feb 2020 20:36:45 +0000</pubDate>
      
      <guid>https://thesharperdev.com/csharps-whenall-and-exception-handling/</guid>
      <description>
      
      Async programming is awesome! It&#39;s fundamental to create scalable and performant web applications. One problem I&#39;ve run into often is how to catch exceptions when using a Task.WhenAll(). Lets take a look at one approach that ensures individual exceptions are caught and then handled or logged.
      
      </description>
    </item>
    <item>
      <title>Reviewing NDepend</title>
      <link>https://thesharperdev.com/ndepend/</link>
      <pubDate>Sun, 19 Jan 2020 20:02:52 +0000</pubDate>
      
      <guid>https://thesharperdev.com/ndepend/</guid>
      <description>
      
      I received a free 1-year license in exchange to use and review NDepend. Rest assured, these thoughts and opinions are my...
      
      </description>
    </item>
    <item>
      <title>Functional Fundamentals: Recursion</title>
      <link>https://thesharperdev.com/functional-fundamentals-recursion/</link>
      <pubDate>Sun, 19 Jan 2020 02:40:13 +0000</pubDate>
      
      <guid>https://thesharperdev.com/functional-fundamentals-recursion/</guid>
      <description>
      
      For loops are everywhere. Recursion is the functional way to iterate through a collection. There are pros and cons to using it over a for loop. Take a peak at what makes it useful and unique.
      
      </description>
    </item>
    <item>
      <title>Thoughts On Becoming More Open Minded</title>
      <link>https://thesharperdev.com/thoughts-on-becoming-more-open-minded/</link>
      <pubDate>Sun, 12 Jan 2020 03:57:08 +0000</pubDate>
      
      <guid>https://thesharperdev.com/thoughts-on-becoming-more-open-minded/</guid>
      <description>
      
      How I think directly impacts my day to day, obviously! Open mindedness is a better way of thinking, but it&#39;s not my default. Lets explore a bit about why it&#39;s so important and how I can become a more open thinker.
      
      </description>
    </item>
    <item>
      <title>The State of TheSharperDev: 2020</title>
      <link>https://thesharperdev.com/the-state-of-thesharperdev-2020/</link>
      <pubDate>Sun, 05 Jan 2020 21:03:04 +0000</pubDate>
      
      <guid>https://thesharperdev.com/the-state-of-thesharperdev-2020/</guid>
      <description>
      
      2019 has been a great year. Lets recap a little of what&#39;s happened here on the blog and give some thoughts about what direction 2020 might have for us.
      
      </description>
    </item>
    <item>
      <title>How to use REPL and Scripting in F#</title>
      <link>https://thesharperdev.com/how-to-use-repl-and-scripting-in-fsharp/</link>
      <pubDate>Tue, 31 Dec 2019 20:49:00 +0000</pubDate>
      
      <guid>https://thesharperdev.com/how-to-use-repl-and-scripting-in-fsharp/</guid>
      <description>
      
      Scripts are great for prototyping! F# can be used as a scripting language. Lets set up a simple example and see how easy it is to script using F#.
      
      </description>
    </item>
    <item>
      <title>Getting Started With BenchmarkDotNet</title>
      <link>https://thesharperdev.com/getting-started-with-benchmarkdotnet/</link>
      <pubDate>Sun, 29 Dec 2019 20:40:29 +0000</pubDate>
      
      <guid>https://thesharperdev.com/getting-started-with-benchmarkdotnet/</guid>
      <description>
      
      Level up with the easiest way to measure the performance of your .NET Code. Stop wondering whether your code is slow, start testing to ensure the code you&#39;re shipping doesn&#39;t have any crippling speed or memory issues. BenchmarkDotNet is the go-to choice for anything performance related in the C#/.NET environment.
      
      </description>
    </item>
    <item>
      <title>Getting Started with Elmish</title>
      <link>https://thesharperdev.com/getting-started-with-elmish/</link>
      <pubDate>Thu, 26 Dec 2019 03:08:18 +0000</pubDate>
      
      <guid>https://thesharperdev.com/getting-started-with-elmish/</guid>
      <description>
      
      UI work is the wild west! Often it&#39;s just iterate until it works. Elmish provides a better set of tools to ensure your UI is working as expected. Why is it so useful? How does it allow you to write UIs that can be checked to ensure they&#39;re working as expected? Lets write a simple Elmish app to demonstrate it&#39;s many advantages.
      
      </description>
    </item>
    <item>
      <title>Introduction to F# Type Providers</title>
      <link>https://thesharperdev.com/introduction-to-fsharp-type-providers/</link>
      <pubDate>Fri, 20 Dec 2019 04:23:08 +0000</pubDate>
      
      <guid>https://thesharperdev.com/introduction-to-fsharp-type-providers/</guid>
      <description>
      
      Types Provides allows compile time checks for your application. Is your SQL syntax right? Are you correctly using the columns from that csv file? It provides a higher level of correctness in your code by having the compiler check your work. Lets walkthrough on what it takes to get a SQL type provider running in F# to ensure your SQL usage is accurate.
      
      </description>
    </item>
    <item>
      <title>The Cost of Abstracting a List in C#</title>
      <link>https://thesharperdev.com/the-cost-of-abstracting-a-list-in-csharp/</link>
      <pubDate>Sat, 14 Dec 2019 02:58:00 +0000</pubDate>
      
      <guid>https://thesharperdev.com/the-cost-of-abstracting-a-list-in-csharp/</guid>
      <description>
      
      There are a lot of ways to return a collection of things. List, IList, IEnumerable, ICollection. Which collection type gives the best performance? Which one should you be using in your code? We benchmark them all to figure out the tidbits of what the costs of each are.
      
      </description>
    </item>
    <item>
      <title>The Difference Between IEnumerable and IQueryable Explained</title>
      <link>https://thesharperdev.com/the-difference-between-ienumerable-and-iqueryable-explained/</link>
      <pubDate>Tue, 03 Dec 2019 08:08:00 +0000</pubDate>
      
      <guid>https://thesharperdev.com/the-difference-between-ienumerable-and-iqueryable-explained/</guid>
      <description>
      
      IEnumerable and IQueryable show up everywhere in C#. Looking at the definitions and their usage, in one aspect they&#39;re pretty similar, but fundamentally they solve difference problems. Lets take a dive into both of these types and see what use case they&#39;re designed for.
      
      </description>
    </item>
    <item>
      <title>Functional Fundamentals: Currying</title>
      <link>https://thesharperdev.com/functional-fundamentals-currying/</link>
      <pubDate>Sat, 30 Nov 2019 19:38:38 +0000</pubDate>
      
      <guid>https://thesharperdev.com/functional-fundamentals-currying/</guid>
      <description>
      
      Functional Programming has certain design principles that make it better suited for solving problems with code. Currying is one of those features. Coming from C#, it might not be something that&#39;s ever seen on your radar. Knowing it and using it will make your code more readable and more composable.
      
      </description>
    </item>
    <item>
      <title>Benchmarking For Loop Variants</title>
      <link>https://thesharperdev.com/benchmarking-for-loop-variants/</link>
      <pubDate>Sat, 23 Nov 2019 03:16:34 +0000</pubDate>
      
      <guid>https://thesharperdev.com/benchmarking-for-loop-variants/</guid>
      <description>
      
      What type of for loop is the fastest? The regular for loop, the foreach loop? Using BenchmarkDotNet, we&#39;ll answer that question and give you the information you need to know when choosing the best for loop for your situation.
      
      </description>
    </item>
    <item>
      <title>Explaining Implicit Conversion Operators in C#</title>
      <link>https://thesharperdev.com/explaining-implicit-conversion-operators-in-c/</link>
      <pubDate>Sat, 16 Nov 2019 18:41:00 +0000</pubDate>
      
      <guid>https://thesharperdev.com/explaining-implicit-conversion-operators-in-c/</guid>
      <description>
      
      C# is a typed language, and generally requires explicit casting when moving between types. But one language feature, implicit conversion, allows you to implicitly move between types. It&#39;s a handy feature that probably shouldn&#39;t be overused.
      
      </description>
    </item>
    <item>
      <title>Under the Hood of C# Alias Types and Namespaces</title>
      <link>https://thesharperdev.com/under-the-hood-of-csharp-alias-types-and-namespaces/</link>
      <pubDate>Thu, 14 Nov 2019 02:41:25 +0000</pubDate>
      
      <guid>https://thesharperdev.com/under-the-hood-of-csharp-alias-types-and-namespaces/</guid>
      <description>
      
      Every C# developer uses the built in types; string, bool or int. But there also exists another set of types, String, Boolean and Int32. What&#39;s the difference? Which one should you use? Lets explore how C# namespaces resolve types and examine C#&#39;s alias types.
      
      </description>
    </item>
    <item>
      <title>Explaining Async Programming With Pizza</title>
      <link>https://thesharperdev.com/explaining-async-programming-with-pizza/</link>
      <pubDate>Sat, 09 Nov 2019 19:34:50 +0000</pubDate>
      
      <guid>https://thesharperdev.com/explaining-async-programming-with-pizza/</guid>
      <description>
      
      Sometimes async programming can be confusing. Sometimes programming tutorials can be pretty confusing. Both can be simple when explained through a delicious medium that we all love and enjoy, Pizza! No more confusion, no more synchronous programming.
      
      </description>
    </item>
    <item>
      <title>Integrating a .NET Core API with Github Actions</title>
      <link>https://thesharperdev.com/how-to-create-a-net-core-api-ci-action-using-github-actions/</link>
      <pubDate>Sat, 02 Nov 2019 19:26:59 +0000</pubDate>
      
      <guid>https://thesharperdev.com/how-to-create-a-net-core-api-ci-action-using-github-actions/</guid>
      <description>
      
      Github actions help you create easy and useful workflows. Want to build/test on every checking, PR that&#39;s opened, or code that&#39;s merged? Github actions have you covered. See what life can be like with some Github actions in your project.
      
      </description>
    </item>
    <item>
      <title>EF Core’s AddAsync v. Add Method</title>
      <link>https://thesharperdev.com/ef-cores-addasync-v-add-method/</link>
      <pubDate>Sat, 26 Oct 2019 19:55:42 +0000</pubDate>
      
      <guid>https://thesharperdev.com/ef-cores-addasync-v-add-method/</guid>
      <description>
      
      Entity Framework is a useful and complex library. One aspect I&#39;ve always been curious about is the AddAsync v. Add method. I finally put the time into researching what the difference is, why you&#39;d use one or the other and some other EF tidbits.
      
      </description>
    </item>
    <item>
      <title>Add Swagger to a .NET Core 3.0 API</title>
      <link>https://thesharperdev.com/add-swagger-to-a-net-core-3-0-api/</link>
      <pubDate>Sat, 19 Oct 2019 18:42:37 +0000</pubDate>
      
      <guid>https://thesharperdev.com/add-swagger-to-a-net-core-3-0-api/</guid>
      <description>
      
      Swagger is an awesome tool for using and testing APIs. Swagger integrates seamlessly with C# and will automatically generate an API interface for your API project. See how easy it is to plug into .NET Core API and start using.
      
      </description>
    </item>
    <item>
      <title>How to Write a Brainfuck Interpreter in C#</title>
      <link>https://thesharperdev.com/how-to-write-a-brainfuck-interpreter-in-c/</link>
      <pubDate>Sat, 12 Oct 2019 10:58:48 +0000</pubDate>
      
      <guid>https://thesharperdev.com/how-to-write-a-brainfuck-interpreter-in-c/</guid>
      <description>
      
      Every programming language is compiled or interpreted to render an output. Learn the basics of how this process works by writing your own interpreter for the brainfuck langauge. A Turing complete language that is only useful for how-to articles like this one.
      
      </description>
    </item>
    <item>
      <title>.Net Core 3.0 AddControllers() Method</title>
      <link>https://thesharperdev.com/net-core-3-0-addcontrollers-method/</link>
      <pubDate>Sat, 05 Oct 2019 10:52:06 +0000</pubDate>
      
      <guid>https://thesharperdev.com/net-core-3-0-addcontrollers-method/</guid>
      <description>
      
      .NET Core has gone through a lot of transformation. Finally in it&#39;s 3.0 release, it finally adds a method that allows you to create an API without any View related code or logic.
      
      </description>
    </item>
    <item>
      <title>C# Design Patterns: The Visitor Pattern</title>
      <link>https://thesharperdev.com/c-design-patterns-the-visitor-pattern/</link>
      <pubDate>Sun, 29 Sep 2019 00:42:31 +0000</pubDate>
      
      <guid>https://thesharperdev.com/c-design-patterns-the-visitor-pattern/</guid>
      <description>
      
      The visitor pattern is commonly used with expression trees. It&#39;s designed to separate data from algorithm. This separation allows for interesting uses, we&#39;ll demonstrate how to print simple mathematical equations in different formats.
      
      </description>
    </item>
    <item>
      <title>An Introduction to C# Expression Trees</title>
      <link>https://thesharperdev.com/an-introduction-to-c-expression-trees/</link>
      <pubDate>Sun, 22 Sep 2019 19:19:27 +0000</pubDate>
      
      <guid>https://thesharperdev.com/an-introduction-to-c-expression-trees/</guid>
      <description>
      
      Entity Framework takes C# queries and turns them into SQL queries. Expression trees power that mapping and transformation. Expression trees are a nerdy language feature you may not know about, but they power a surprising amount of things in C#.
      
      </description>
    </item>
    <item>
      <title>The Cost of Synchronous Async Methods</title>
      <link>https://thesharperdev.com/the-cost-of-synchronous-async-methods/</link>
      <pubDate>Sun, 15 Sep 2019 19:22:43 +0000</pubDate>
      
      <guid>https://thesharperdev.com/the-cost-of-synchronous-async-methods/</guid>
      <description>
      
      Async methods are one of the best tools to write performant and scalable web applications. But what is the cost of having async methods that don&#39;t actually have any asynchronous functionality? I&#39;m sure you&#39;ve written one before. Lets take a look at how it degrades the performance of the function.
      
      </description>
    </item>
    <item>
      <title>Pure v. Impure Functions</title>
      <link>https://thesharperdev.com/pure-v-impure-functions/</link>
      <pubDate>Sun, 08 Sep 2019 18:59:40 +0000</pubDate>
      
      <guid>https://thesharperdev.com/pure-v-impure-functions/</guid>
      <description>
      
      Pure functions make your life and code better. Every function you write is either Pure or Impure. It&#39;s an important distinction that is never really taught in school or at most jobs. Learn about how writing pure functions can make your code easier to test and free from side effects.
      
      </description>
    </item>
    <item>
      <title>About Me</title>
      <link>https://thesharperdev.com/about-me/</link>
      <pubDate>Sat, 31 Aug 2019 17:16:24 +0000</pubDate>
      
      <guid>https://thesharperdev.com/about-me/</guid>
      <description>
      
      Everyone has a story and mine is fairly simple. I&#39;m a regular programmer who had an itch to start a blog. Now I&#39;ve got one more thing to juggle on my plate.
      
      </description>
    </item>
    <item>
      <title>Launching “The Sharper Dev” Blog!</title>
      <link>https://thesharperdev.com/hello-world/</link>
      <pubDate>Sat, 31 Aug 2019 11:05:47 +0000</pubDate>
      
      <guid>https://thesharperdev.com/hello-world/</guid>
      <description>
      
      Everyone has a start. Welcome to the start of my blog, I&#39;m looking forward to this adventure
      
      </description>
    </item>
    
  </channel>
</rss>
