Dan Schnau's Blog

Some Mental Health Notes

2026-04-15T19:21:44.287Z

My therapist applies Internal Family Systems as part of her therapy.

At the end of our discussion, we reviewed the process as she describes it.

Be Curious about the part that is causing problems.
Communicate understanding about that part.
Show Appreciation for that part. It is in fact trying to help, just in a maladaptive way.
Negotiate. Find a way to let the part relax its grip on your psyche by giving it some of what it needs.
Reassure this part. Regularly check in with yourself, and see that you haven't broken your negotiated deal.

Kagi Search

2026-04-09T19:04:41.98Z

A couple days ago I signed up for Kagi search on a trial. Today I hit that trials' cap and happily ponied up the $5/month for ad-free search.

Even with ad-blocker extensions, I found the help from Kagi search to be superior.

focus

2026-04-08T16:49:00.89Z

Man, it's hard to focus in this day and age.

I noticed yesterday that when I was having a hard time focusing on what I needed to do (some tasks for work and meal planning for the family), I typed out my thinking. As I typed, my thinking became slower and more direct. I got the tasks done and I prepped that day and the following day's meals.

It's no secret that writing is good for this sort of thing. I'd like to do more of it.

No, Sam Altman Cannot Be Trusted

2026-04-07T18:33:50.55Z

I've seen a headline come up recently for a New Yorker article: Can Sam Altman Be Trusted?

I haven't read the article, but, I can answer the question, and the answer is no.

This is a guy who justified the energy usage from training Large Language Models by comparing it to the energy needed to raise a human being.

One of the things that is always unfair in this comparison is people talk about how much energy it takes to train an AI model relative to how much it costs a human to do one inference query. But it also takes a lot of energy to train a human.

It takes a lot of energy to train a human. It takes, like, 20 years of life, and all of the food you eat during that time before you get smart.

You cannot trust a for-profit company to begin with (they're for-profit, not for-people), and you especially can't trust one with a leader who says fucked up stuff like that.

Trump Needs To Go

2026-04-07T18:14:43.807Z

Today The President Of The United States Of America Threatened To commit Genocide. The president wrote the following:

A whole civilization will die tonight, never to be brought back again. I don’t want that to happen, but it probably will. However, now that we have Complete and Total Regime Change, where different, smarter, and less radicalized minds prevail, maybe something revolutionarily wonderful can happen, WHO KNOWS? We will find out tonight, one of the most important moments in the long and complex history of the World. 47 years of extortion, corruption, and death, will finally end. God Bless the Great People of Iran!

Twice I've voted against Trump. In 2020 I volunteered my time to work the phones for the democratic party.

There are a pocket of trumpers that meet on Sunday afternoons near my home and wave their flags. People honk their horns in support.

I have made it a habit to do my grocery shopping on Sunday afternoons so that I may have a chance to yell expletives at these Trump supporters.

It's long since past time this pedophile, warmonger, scammer, absolute slime of a human being is removed from power.

Learning some graphics from scratch

2026-03-14T02:19:56.62Z

I've taken interest in learning some low-level graphics programming. I did get into software originally because I wanted to make video games. I just got lazy about it in college.

Anyway. I learned a bit about OpenGL Vulkan, and SDL.

I've gotten started working through the examples on the LibSDL site.

Re: Service idea: roll-your-own streaming subscription (with artist royalties!)

2026-03-13T18:39:14.213Z

I came across this post describing a "DIY Spotify" where basically instead of paying Spotify to keep my money and not pay artists, I pay artists directly with my monthly music-spend allocation. It sounds really cool.

https://laze.net/2026/03/02/service-idea-rollyourown-streaming-subscription.html

Coding With Claude - Install LSP (Language Server Protocol) Support

2026-02-19T17:47:37.163Z

Reading the docs for Code Intelligence I learned you can make Claude run way faster.

By default, when Claude is writing code, it's using tools like grep and running builds to find errors and explore the codebase.

But as a human writing code, we don't work like that! Usually, at least. We have the luxury of squiggily lines under errors, and go-to-definition to speed up development. Claude can benefit from the same.

LSP integrations are implemented as plugins with claude, so installing them is a matter of a /plugin command.

/plugin install csharp-lsp

Adding LSP support for Claude will both allow Claude to run faster and more token-efficient.

You can find a list of out-of-the-box supported languages here.

Artificial Intelligence Predictions for 2026

2025-11-21T00:12:53.1Z

My prediction for AI in 2026 is that it's just gonna keep growing. I don't think it's some kind of bubble. Some of the things people are trying with LLMs won't work out, but plenty will.

We Are In The Trough Of Disillusionment

We are here:

LLMs Are Not Your Friend

LLMs, the tech that is now synonymous with AI, is a technology for figuring out the next best thing to say. I think of it as a digital "yes man". You can't talk to them like they're your friend and get a real relationship like it's with a human being. The AI Girlfriend apps are way creepy.

AI Will Not Replace Software Engineers

Have you ever heard the saying that there are two parts to every software project? The first 90%, and the second 90%? AI is great at getting that first 90% done, and also making that second 90% even more arduous.

I've seen enough AI code slop to be confident that my software engineering skills will be needed for some time, even with lots of fun "vibe coded" software getting churned out. I'm interested to see how much the "get your vibe-coded app ready for production" industry grows.

AI Is Really Helpful For Writing Code

Having said that ChatGPT isn't going to replace software engineers, I also want to share that I find ChatGPT very useful for software engineering. Recently, I needed to write a function that would return a TimeSpan until the next time a job should run, and there were very specific business rules around it. I detailed those rules to ChatGPT and it gave me a function that worked correctly. After reviewing and testing the code as I would any other software going in to a production system, it became "my code" rather than "vibe code". And it made my life a bit easier.

You Can't Really Trust What AI Business People Or News Articles Say

Because there is so damn much money invested in companies with Large Language Model technology, the leaders of those businesses need to keep their investors happy. At least, happy with their investments. As such, any shortcomings or problems will be hidden as much as possible, and any successes will be hyped up. Because this is the next exciting big thing, news articles are going to hype things up as much as they can, in both positive and negative perspectives, because that gets the clicks and the traffic. That's the world we live in.

There's usually some truth to the matters at hand, but more often than not, things are made out to be more exciting than they really are.

Some News

Just for reference of recent events when I look back at this.

Anthropic, owners of the Claude programming IDE, announced on November 11, 2025 that it would be investing 50 Billion Dollars in AI infrastructure.

Nvidia, a computer chip maker, announced on September 22, 2025 that it would be investing Up To 100 Billion Dollars in OpenAI.

OpenAI, the company that owns ChatGPT, has reached a valuation of 500 Billion Dollars as of this news from October 2, 2025.

I saw a bunch of headlines about how the Big Short guy had bet against AI markets, but now I can't find any articles with specific numbers. It leads me to think that those headlines were more click-bait than real evidence that we're in an AI bubble where a bunch of money is going to evaporate one day. It looks to me more like a couple of people just arguing on the internet.

Gradual Migration: Moving from MVC to Blazor Without Breaking Everything

2025-03-26T20:29:49.167Z

Introduction: Why Migrate to Blazor?

Blazor brings the power of modern web development to .NET developers, enabling rich interactivity using just C#. But most existing enterprise applications still rely on ASP.NET MVC. Rewriting an entire application overnight isn’t realistic, so this post outlines how to move from MVC to Blazor gradually, without breaking everything in the process.

Step-by-Step Migration Strategy

1. Start with Shared Models and Services

Example: Refactor your business logic into a service:

public interface IProductService
{
    Product GetProductById(int id);
}

public class ProductService : IProductService
{
    public Product GetProductById(int id)
    {
        // Fetch from DB or cache
    }
}

Then inject and use it in both a controller and a Blazor component:

In MVC Controller:

public class ProductController : Controller
{
    private readonly IProductService _productService;

    public ProductController(IProductService productService)
    {
        _productService = productService;
    }

    public IActionResult Details(int id)
    {
        var product = _productService.GetProductById(id);
        return View(product);
    }
}

In Blazor Component:

@inject IProductService ProductService

@code {
    [Parameter] public int Id { get; set; }
    private Product product;

    protected override void OnInitialized()
    {
        product = ProductService.GetProductById(Id);
    }
}

2. Use Blazor Components in Razor Views (Where Appropriate)

Example: Embed a Blazor component into an MVC .cshtml view:

<component type="typeof(MyApp.Components.MyWidget)" render-mode="ServerPrerendered" />

Make sure the _Imports.razor and service registration for Blazor Server are correctly configured.

3. Isolate Blazor Areas for New Features

For any new feature, consider building it in Blazor from the start. You can keep MVC for legacy parts while introducing Blazor for greenfield work. Use consistent routing to make the experience seamless.

4. Gradually Replace High-Interaction Pages

Pages that involve lots of JavaScript, dynamic forms, or live updates are prime candidates for Blazor. These benefit most from Blazor’s signal-driven updates and component model.

5. Introduce a Hybrid Navigation Strategy

A quick note: this kind of hybrid approach—mixing Blazor and MVC—is different from "Blazor Hybrid," which refers to running Blazor components in both client-side and server-side contexts (often used in desktop scenarios with .NET MAUI). Here, we're talking about a web-focused strategy that blends traditional MVC routing with Blazor navigation.

Mix traditional MVC navigation (RedirectToAction, <a href>) with Blazor’s <NavLink> carefully. Keep navigation consistent with shared layout components and links that bridge both worlds.

6. Manage Authentication and Layouts Across Both Frameworks

Use shared layout files, partials, or component libraries where possible. For authentication, use the same middleware and claims-based identity so users don’t have to reauthenticate between sections.

7. Remove Unused Features

Migration is also a great opportunity to clean house. As you assess which parts of your MVC app to rebuild in Blazor, take note of outdated or unused features. If certain pages, reports, or admin tools haven’t been touched in months (or years), consider whether they need to be migrated at all. Trimming unused code keeps your new Blazor app leaner, easier to maintain, and more focused on what users actually need.

Final Thoughts: Tips, Pitfalls, and When to Go All-In

A full migration to Blazor is tempting—but not always necessary. Start small, prioritize user experience, and lean on shared services to minimize duplication. Avoid trying to copy MVC patterns directly into Blazor; embrace the component model instead. When your team is comfortable and the codebase is ready, a full move may make sense—but until then, hybrid works just fine.

Execute on a simple idea: building LinkDisguiser.com

2025-03-29T22:17:10.123Z

Introduction

LinkDisguiser.com is a project I built to explore the capabilities of Azure Table Storage while solving a practical problem—creating a scalable and cost-efficient way to manage and disguise links. This post will walk through the inspiration behind the project, the technical decisions involved, the challenges faced, and the future enhancements I have planned.

The Inspiration Behind LinkDisguiser.com

I wanted to build a project that leveraged the power of Azure Table Storage to handle large-scale data efficiently while remaining cost-effective. The challenge was to design a system that could store and retrieve short links quickly using partitionKey and rowKey, taking advantage of Azure's highly optimized querying. This project was an opportunity to apply and test what I had learned about scalable, cloud-based storage solutions in a real-world application. A similar approach is used by sites like haveibeenpwned, which also rely on fast, partitioned lookups to deliver high-performance data access at scale.

Technical Decisions and Architecture

The backbone of LinkDisguiser.com is Azure Table Storage, which is used to store link redirects and tracking data. This choice was driven by its low cost, scalability, and fast access when queries are optimized around the partitionKey and rowKey structure. These keys allow efficient, targeted lookups that help the system scale with minimal performance trade-offs.

In addition to Azure Table Storage, the architecture includes a minimal C# API that powers the short domain lkdr.xyz, hosted via Azure App Service. This API is responsible for processing and redirecting shortened links. The main frontend site, linkdisguiser.com, is hosted as an Azure Static Web App, which keeps the overall hosting cost low and simplifies deployment. This combination of services results in a fast, inexpensive solution with very little code to maintain.

The redirection mechanism under the hood is simple and lightweight. When a shortened link is accessed via lkdr.xyz, the C# API queries Azure Table Storage using the optimized keys, finds the target URL, and performs the redirect. This lean setup is highly effective without requiring a heavy backend or database infrastructure.

Future Enhancements

Looking ahead, several new features are planned to make LinkDisguiser.com more powerful and user-friendly. One major addition will be link performance tracking, allowing users to see how often their links are clicked and from which locations. This will provide valuable insight into engagement and reach.

Another upcoming feature is QR code generation for each shortened link, making it easier to share links in physical or visual formats like flyers, presentations, or signage.

Additionally, I'm considering introducing paid support plans for users who want enhanced features, priority assistance, or usage at higher volumes. These enhancements aim to balance usability, scalability, and sustainability as the project grows.

Final Thoughts

Building LinkDisguiser.com has been a rewarding experience, combining practical problem-solving with the exploration of scalable cloud technologies. It's a reminder that even simple tools can have impact when built thoughtfully. I hope this project encourages others to start small, experiment, and learn through building. If you have ideas, feedback, or feature requests, I'd love to hear from you.

Link Shortening with LinkDisguiser.com and lkdr.xyz

2025-03-25T02:06:07.483Z

LinkDisguiser.com has been updated to improve link shortening. The service now uses lkdr.xyz to generate shorter links that are easy to share.

What's New?

Shorter Links: The new domain, lkdr.xyz, makes shortened links more compact.

Technical Details

Azure Table Storage: Link redirects and click tracking are stored in Azure Table Storage for reliable performance.
Hosting: lkdr.xyz is hosted on an Azure App Service, while LinkDisguiser.com runs on a static web app for scalability.

Future Enhancements

Additional analytics may be introduced to provide insights into link clicks, including geographic data, device types, and referral sources.

Why Use LinkDisguiser.com?

LinkDisguiser.com provides a simple and effective way to shorten URLs for social media, email campaigns, or general use. The service is free and does not require signups.

More updates may follow as the project develops.

How to hide warnings in the dotnet cli

2025-02-18T22:09:32.3Z

To hide warnings with the dotnet cli in commands such as dotnet build or dotnet test - you have to pass a flag to the underlying msbuild system.

dotnet build --property:WarningLevel=0.

This doesn't make Warnings not happen - but if you know you're not going to be fixing them, it gets them out of the way of your shell.

Table Capture: A Very Good Browser Extension

2024-11-19T18:16:22.367Z

Today I wanted to find a way to extract data from my banking portals faster. Usually, I use the "export to csv" feature, then manually copy/paste that csv data into the "master" spreadsheet. This is how my wife and I keep track of our finances.

But this process is tedious. I wanted to be able to copy data directly from the html <table> I see when I first log in to my banking portal.

For this purpose I found the browser extension Table Capture.

This extension allowed me to select any html table on a page and copy/paste directly into my spreadsheet. It's a great tool.

Table Capture Extension for Edge

Table Capture Extension for Chrome

Table Capture Extension for Firefox

How to Add a Blazor Server App to an ASP.NET Model/Controller Web API

2025-02-18T22:09:03.52Z

Blazor is a modern framework for building web applications with C#/.NET. Blazor apps can run "anywhere" in a variety of rendering modes. Blazor supports building pre-rendered static sites, server rendered web applications, and client-rendered web applications. With .NET 8, these rendering modes can be mixed and changed on a component-by-component basis.

This post focuses on using Blazor Server to render a web application. Blazor Server handles changes on the server then streams DOM updates to the browser via a SignalR connection.

ASP.NET Web API is a modern, but older and very mature, framework for building Web APIs with C#/.NET.

You can write a Blazor Server project to retrieve data without using ASP.NET WebAPI, this post will focus on adding a Blazor Server App to an existing Model/Controller WebAPI project.

We will first set up a sample Web API project with Controllers. Then we will set up a sample Blazor server application.

Then, we will merge the two together. Finally, we will write the code to invoke the Web API controller from the Blazor Server app.

Creating an ASP.NET Controller API

First, let us set up a Web API project. With the dotnet cli, this is a one-line command in a terminal.

dotnet new webapi --name add_blazor_server -controllers

The --name argument there, add_blazor_server, can be whatever you want your project to be named. -controllers specifies to use Controllers for your project rather than a newer "minimal API" project template.

In that screenshot we can see the contents of the root of the project. A few highlights:

Controllers is the directory for our API Controllers.
add_blazor_server.csproj is the project file that specifies things like NuGet package dependencies and which version of .NET to use.
add_Blazor_server.http is a file that specifies a request with which you can test the api. This is a convenient tool for those of us used to more heavyweight tools such as Postman.
appsettings.json and appsettings.Development.json are JSON configuration files for application settings. Some things are pre-defined in them.
Program.cs is the Entry Point of the project.
WeatherForecase.cs provides a sample Model object for us to work with.

Creating a Blazor Server App

Now that we have our API Controllers, we can add a Blazor Server application.

In order to understand this, lets create a sample Blazor server project and look at a few things.

Just like the Web API project, we can create a blazor server project with the dotnet cli:

dotnet new blazorserver --name demo_blazorserver

Inside our demo blazor server project, we have some overlapping files with our WebApi and some new things. Here are a few highlights:

Data provides some sample Data Access features for the blazor server app. Our objective will be to use the Blazor Server app with the API provided by ASP.NET Web Api instead of this.
Pages, Shared, and wwwroot are all for our Blazor Server razor pages UI experience. We'll keep these.
Program.cs is here as well and we will need to merge what happens in here with our Program.cs in our Web API project.

Integrating Blazor with ASP.NET Web API

Adding Blazor to the ASP.NET Project

Now, let's add to the Web API project what we will need to run a blazor server and Web API Controller together in a single project.

First, we will add what we need in the Web API project's Program.cs. In the Services setup, we need to invoke a few methods to register Blazor Services.

builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

Then, in that same file we set up middleware, we add Blazor pipelines middlewares. Add them after the MapControllers() call so that our API controllers get "first dibs" at an incoming HTTP request.

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
   app.UseSwagger();
   app.UseSwaggerUI();
}

app.UseHttpsRedirection();
 
app.UseAuthorization();
 
app.MapControllers();
 
app.UseStaticFiles();
app.UseRouting();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");
 
app.Run();

Then, we can copy some things. Copy App.razor, _Imports.razor, wwwroot, Shared, and Pages.

Make sure the namespaces are aligned properly in the single project.

You'll get a few errors related to a missing Data namespace. Remember, this is the sample data access code from our blazor server app. We're going to change this code to use our Web API controller instead.

After removing broken dependencies from the FetchData.razor page, we have an app that runs, but the FetchData page doesn't do anything.

We can run the app with dotnet run and give this a test.

But, we can get the data if we point our browser directly at the route for our API controller.

So, we have our app running both a Web API controller and a Blazor Server app. All that's left is updating some code in our Razor component, so the Blazor Server part of our app can call the Web API controller part of our app.

Making WebAPI Controller calls in Blazor Server

Let's make an API call in our FetchData.razor call to replace the WeatherForecastService code we removed.

First, we set up a new Service in Program.cs, the HTTP Client. This allows us to inject an HTTPClientFactory into our Razor component so we can make HTTP calls.

builder.Services.AddHttpClient();

Then, in FetchData.razor, we inject two services, NavigationManager and HttpClientFactory. We will need the NavigationManager, a class provided by the Blazor framework, so the HTTPClient knows what URI to call.

While both the web api and the blazor server app are running in the same runtime here, this httpclient could make http calls out to whatever endpoints it has access to.

@inject IHttpClientFactory HttpClientFactory
@inject NavigationManager NavigationManager

Then we can update the OnInitializedAsync() call of our FetchData component.

protected override async Task OnInitializedAsync()
{
    var httpClient = this.HttpClientFactory.CreateClient();
    httpClient.BaseAddress = new Uri(NavigationManager.BaseUri);
    forecasts = await httpClient.GetFromJsonAsync<WeatherForecast[]>("/weatherforecast");
}

Then we ran run our app one more time with dotnet run and see that the 'Fetch Data' page is pulling data from our Web API Controller.

Conclusion, Review, and Source Code on Github

This article provides a step-by-step guide to combining Blazor Server with an ASP.NET Web API, ensuring seamless data integration and a functional web application.

We first made a sample Web API project, and a sample Blazor Server project. We accomplished this with a few commands from the dotnet cli, a tool that the author is particularly fond of.

After that, we walked through migrating the Blazor server functionality into the Web API project.

Once that was running, we programmed a Blazor server razor component to make HTTP calls to our Web API controller in the same project.

We included a few screenshots of the app along the way. If you would like to see all the code together, you can check it out at GitHub here: https://github.com/dsschnau/add_blazor_server_app_to_aspnet_web_api. Great job, thanks for reading!

LinkDisguiser.com, BlankWallpaper.com, and TopTechSites.com

2024-11-01T17:53:38.863Z

A while back I went domain name shopping and picked up a few cool sounding domains. Using Azure Static Webapps, I built sites for each. Each site is in "alpha" release, and I plan on adding more features and content to these sites over time.

LinkDisguiser.com

!Home Page for Link Disguiser Dot Com

What better thing to do with the domain LinkDisguiser.com than to build a link disguiser, or a link shortener. I consider this first version an 'alpha' version, where links are saved mapped to some random words, and redirects are transparent because disguised links first go to a landing page saying where the disguised link will redirect to. I invite you to give it a try.

BlankWallpaper.com

BlankWallpaper.com was a foray into generating images with a C# Azure Function. Taking arguments of Color and resolution, this site will generate a blank wallpaper image for the user (or, deliver one that was already generated).

TopTechSites.com

This domain seemed too good to pass up, but, now I don't have any great ideas for what to do with it. Right now, it's just a page of static links to a big list of tech sites. I'm pretty sure some of them are defunct already.

Walkthrough: Deploy a Blazor WASM app running on a Free Azure Static Webapp instance

2024-05-22T00:00:40.507Z

Azure Static Web Apps are one of my new favorite things. Azure static apps are essentially static file servers - there's no compute resources available on them. They're optimized to work for front-end applications e.g. Blazor WASM, Angular, Vue, React, etc. In order to support server-side compute, Azure Static Apps integrate with Azure Functions.

What I love about this stack is that it's all free for small projects. They provide a free 'hobbyist' tier, and free SSL certificates, so the only thing you need to pay for is a domain (and even then you can skip that and use a generated *.azurestaticapps.net domain). For Azure functions, the first million requests per month are free. After that they're still dirt cheap.

Create a Blazor WASM Project and Deploy to Azure Static Webapp

Let's walk through how to deploy a blazor wasm project to an azure static webapp. I happened to recently buy the domain blankwallpaper.com, so we will make an app for generating blank wallpapers and get it deployed.

In order to start, you'll need accounts on Microsoft Azure and Github, and a blank Github repository to work with. In my case it is a private github repo called dsschnau/blankwallpaperdotcom. If you are reading this and learning to build web applications from scratch, I suggest learning Git and GitHub from another resource.

Using the dotnet CLI, I can spin up a new blazor wasm application, and push it to my repo in GitHub.

From the azure portal, we first create a Static Web App resource, and walk through a few bits of configuration.

Then we need to configure a few things. GitHub and Azure are tightly integrated (Microsoft owns GitHub after all 😅) so finding my repo is straightforward.

We can leave the 'Advanced' section by default, so here's the preview before running the deployment

The deployment takes about 20 seconds.

This deployment does two things. First, it creates the resource in Azure. Then it creates a Github Actions Job and automatically kicks off the first deployment. After about a minute, the first deploy is done, and our hello world app is deployed. Subsequent commits to main will trigger new deployments.

Off to the races! This leaves off configuring Azure Functions as a backend and Custom Domains. I will save those subjects for another day.

Will Blazor Replace MVC? Exploring the Future of Web Development

2024-05-16T02:57:16.793Z

Will Blazor Replace MVC?

Blazor and MVC are two distinct technologies in the realm of web development, each with its own set of advantages and use cases. Let's delve into the differences between them to understand their roles in modern web application development.

Is Blazor Better than MVC?

While Blazor offers a novel approach to building web applications entirely in .NET/C#, it's essential to recognize that it's not intended to replace ASP.NET MVC outright. Blazor is tailored for developing single-page applications (SPAs) or experiences akin to SPAs, where .NET languages like C# are exclusively used. On the other hand, MVC remains a reliable choice for traditional web application development.

If your objective is to create a dynamic, interactive SPA, Blazor may be the preferable option due to its seamless integration with WebAssembly (WASM), delivering exceptional client-side performance. However, for projects requiring a more conventional web application experience, MVC is likely to be the more suitable choice.

Is ASP.NET MVC Still Relevant in 2024?

A resounding yes! ASP.NET MVC continues to be widely utilized in web development, including this very blog you're reading. Numerous enterprise-grade applications rely on MVC, benefiting from its robust architecture and steadfast support from Microsoft.

ASP.NET MVC adheres to the Model-View-Controller pattern, providing a structured approach to building web applications. Requests are handled by controllers, which interact with models and render views for user consumption. With its proven track record, MVC boasts excellent performance and a thriving community of developers and resources.

Exploring Blazor Hosting Models

Blazor introduces innovative hosting models that distinguish it from MVC. Unlike MVC, where client-side scripting often involves JavaScript, Blazor enables the execution of both server and client code entirely in .NET/C#. This capability is made possible by WebAssembly, which allows .NET code to run directly in web browsers.

Blazor supports multiple hosting models, including:

Blazor WebAssembly (WASM): Ideal for client-side applications, Blazor WASM leverages WebAssembly to deliver high-performance .NET code directly in the browser.
Blazor Server: In this model, Blazor applications run on the server, with updates sent to the client via a SignalR pipeline. It's suitable for scenarios where real-time communication and server-side processing are paramount.
Blazor Hybrid: Combining elements of both Blazor WASM and Blazor Server, the hybrid model allows for a mix of server-side and client-side execution, offering flexibility in application architecture.

While Blazor presents exciting opportunities for modern web development, it's important to recognize that it complements rather than replaces MVC. Both technologies coexist, catering to diverse project requirements and development scenarios.

There really isn't much use in doubting yourself at work.

2024-03-08T17:21:08.443Z

There really isn't much use in doubting yourself at work.

Eloquent JavaScript is a good book

2024-03-07T17:36:14.653Z

I learned from Hacker News today that Eloquent Javascript is now in it's 4th edition. About ten years ago, I read this book and worked through every exercise in it. It gave me a deep understanding of JavaScript, and I recommend this book to many people still.

FunctionInputConverterException: Azure Functions in .NET dotnet-isolated process get a FunctionContext rather than an ExecutionContext

2024-01-25T17:36:18.663Z

When you upgrade an Azure Function to .NET 8 dotnet-isolated model, the Webjobs namespace goes away, and gets replaced by the Microsoft.Azure.Functions.Worker namespace.

In the Webjobs namespace, there is a ExceutionContext that you can inject into your function. Here's a writeup on that from 2020: Quick tip: using ExecutionContext in Azure Functions.

This is no longer available in the Azure.Functions.Worker namespace. By the docs at learn.microsoft.com:

The logger can also be obtained from a FunctionContext object passed to your function.

So, you can replace any usage of ExecutionContext with FunctionContext. But here's the gotcha: there also exists a System.Threading.ExecutionContext class. Any C# that uses the System.Threading.Task class involved with the await / async pattern is likely to be using this namespace. The result is that any references to an ExcecutionContext will happily pass the compiler even with the Webjobs packages uninstalled, and that may lead to cryptic runtime errors.

So when you migrate to dotnet-isolated functions, make sure you aren't inadvertently referencing a System.Threading.Execution context in your Func signature, or you'll get hit with the Microsoft.Azure.Functions.Worker.FunctionInputConverterException.

Azure Functions Error Debug: Running processor on exception: '/' is invalid after a value. Expected either ',', '}', or ']'

2024-01-24T16:10:49.1Z

As it turns out, Azure Functions might not like "comments" in your host.json, and it will fail awkwardly.

  "version": "2.0",
  "functions": [
    "myfunc"
    //"myotherfunc" <--- THIS WILL BREAK THE FUNCTIONS APP
  ],
  "someMoreJsonHere" : { }

Console output:

Debug: Running processor on exception: '/' is invalid after a value. Expected either ',', '}', or ']'. Path: $.functions | LineNumber: xx | BytePositionInLine: xx.

Use Azure DevOps CLI to Navigate Directly To A Pipeline

2024-01-23T14:58:49.76Z

Using the Azure Devops Extension to to the Azure CLI, you can navigate directly to pipelines in your browser without having to click through the Azure Devops UI.

Windows PowerShell
Copyright (C) Microsoft Corporation. All rights reserved.

Try the new cross-platform PowerShell https://aka.ms/pscore6

PS C:\Users\danschnau> az pipelines list --name *myproj* --output table
ID    Path     Name               Status    Default Queue
----  -------  -----------------  --------  ---------------
1233  \Build   myproj         enabled   Azure Pipelines
1234  \Deploy  myproj-deploy  enabled   Azure Pipelines

PS C:\Users\schnaud> az pipelines show --id 1233 --open
ID    Path    Name        Status    Default Queue
----  ------  ----------  --------  ---------------
1360  \Build  myproj  enabled   Azure Pipelines
PS C:\Users\danschnau>

The first command searches for any pipelines that contain the string myproj in their name. A list of projects come out with names and ids. The last command will open up the pipeline in your browser, specified by the ID.

Handling HTTP 409 Errors editing files in Azure App Service Editor

2024-01-15T18:14:15.417Z

I was getting HTTP 409 errors when editing an Azure Function app, I couldn't understand why. A Bing search led to this blog post from Chaminda Chandrasekara which helped me out. If the configuration WEBSITE_RUN_FROM_PACKAGE is set to 1, the app service editor returns 409 errors when you try to edit files. I set it to 0, restarted my function app, and I could make changes again.

When I'm done, I'll set it back to 1 for the sake of performance.

Generate an IEnumerable of a given size, going half "Down", half "Up"

2024-01-10T15:13:20.703Z

I sometimes want to generate a list of numbers going "up" and "down" from a given number (usually, the ID of an entry in a database). Sometimes I've done this by hand. But with Enumerable.Range, generating a list like this makes for a nice snippet of C# code.

var startingPoint = 999; // or wherever you want to start
var size = 10;
var list = Enumerable.Range(startingPoint-(size / 2), size);

PWAs Seem Really Good

2024-01-08T14:43:56.44Z

This site was at the front of Hacker News this morning: https://whatpwacando.today/. I think it's rad how much can be built that runs "natively" from a browser. I'd like to explore further what, say, a Blazor app can do running as a PWA.

Experimenting with performances gains from Blazor WASM AOT Compilation 2.0

2024-01-25T16:20:30.447Z

In my previous post I had left open a problem of a 100ms delay that forced the screen to repaint.

I've been working out what is required to make sure the screen paints between each assignment of a new Base64 to the <img> tag in the DOM.

After some discussion in Discord with Marek Fišera, I've gotten the "forced delay" down to a single millisecond:

private async Task DrawStar()
{
    using (Image<Rgba32> image = new(TimesCompleted * 10, 200))
    {
        Star star = new(x: 100.0f, y: 100.0f, prongs: 5, innerRadii: 20.0f, outerRadii: 30.0f);
        image.Mutate(x => x.Fill(Color.Red, star));
        ImgString = image.ToBase64String(JpegFormat.Instance);
    }
    TimesCompleted++;
    StateHasChanged();
    await Task.Delay(1);
    await Task.Yield();
}

As a result, I get a more accurate picture of JIT vs AOT compilation for this little test case.

JIT:

> AOT - and take note, AOT compilation takes a long time! This little app took 6 minutes and 14 seconds to compile: > And now the performance difference is **five-fold**!

Update 1/23/24: while browsing the Fediverse this morning, I found a much more comprehensive investigation of Blazor's WASM performance by one Kristoffer Strube.

Experimenting with performances gains from Blazor WASM AOT Compilation

2023-12-17T04:38:07.31Z

It would appear that AOT compilation gets substantial performance improvements in client-side application performance.

I put together a tech demo running Blazor client side WASM. The code for the main component is at the bottom of this post.

The gist is this: draw an image, using the SixLabors ImageSharp library, 20 times. Each image is slightly wider than the previous, and post the time taken.

In my experiments, it takes about 1/3rd as much time to complete with Ahead-of-time compilation.

Here's the test without AOT compilation:

And the same test, compiled with AOT:

Obviously, this is an anecdotal test, but it would certainly appear to me that AOT compilation can make for some very fast client-side image processing applications.

Code below:

@page "/"
@using SixLabors.ImageSharp
@using SixLabors.ImageSharp.Drawing
@using SixLabors.ImageSharp.Drawing.Processing
@using SixLabors.ImageSharp.Formats.Jpeg
@using SixLabors.ImageSharp.Formats.Png
@using SixLabors.ImageSharp.PixelFormats
@using SixLabors.ImageSharp.Processing
@using System.Diagnostics

<PageTitle>Home</PageTitle>

<h1>Blazor WASM AOT performance testing</h1>

<button @onclick="_ => StartWork()" disabled="@started">Start</button>

<p>milliseconds to @TOTAL_ITERATIONS draws: @TimeTaken</p>

<img src="@ImgString" />

@code {
    const int TOTAL_ITERATIONS = 20;
    private string? ImgString { get; set; }
    private long TimeTaken { get; set; }
    private int TimesCompleted { get; set; }
    private bool started { get; set; } = false;

    private Stopwatch Timer { get; set; } = new Stopwatch();

    private async Task StartWork()
    {
        started = true;
        TimesCompleted = 1;
        Timer.Start();

        while(TimesCompleted < TOTAL_ITERATIONS)
        {
            await DrawStar();
        }

        Timer.Stop();

        TimeTaken = Timer.ElapsedMilliseconds;
    }

    private async Task DrawStar()
    {
        using (Image<Rgba32> image = new(TimesCompleted * 10, 200))
        {
            Star star = new(x: 100.0f, y: 100.0f, prongs: 5, innerRadii: 20.0f, outerRadii: 30.0f);
            image.Mutate(x => x.Fill(Color.Red, star));
            ImgString = image.ToBase64String(JpegFormat.Instance);
        }
        TimesCompleted++;
        StateHasChanged();
        await Task.Delay(100);
        Console.WriteLine(this.ImgString);
    }
}

This Blog Is Migrated to Blazor Static Server Side Rendering

2023-12-15T18:00:56.797Z

I'm excited to share that https://danschnau.com is now hosted with Blazor Static Server side rendering. Because this site is not a particularly complicated app, it didn't take too much to make this happen.

Including Razor Components (the stuff of Blazor) services is a one-liner in program.cs.

builder.Services.AddRazorComponents();

Hosting the root Blazor App is also a one liner in program.cs. There are a few things I want to keep as MVC, for example, support for atom feeds, so I didn't remove the MVC services, and place MVC routing after the blazor components. With this, the blazor app gets "First dibs" at an incoming http request, and if it doesn't want to handle the request, MVC gets it's chance at it.

app.MapRazorComponents<App>();
app.MapControllerRoute("default", "{controller=Home}/{action=Index}/{id?}");

The result is that browsing pages is pretty screaming fast.

"Getting Started With Blazor" at Michigan DevFest 2023

2023-12-03T16:45:57.14Z

Not long after I was laid off, I signed up to give a tech talk at Michigan DevFest 2023, a tech conference in downtown Detroit.

I expected that facing the public-speaking fear would keep my skills sharp, help me land a job, and have some fun along the way. Blazor is a new framework for building web applications from Microsoft, and I've been interested in it for some time, so this was a good opportunity to learn more.

The conference was set to take place in December, and I submitted an abstract in September.

In late October, I accepted an offer and began my new job at Detroit Trading Company. I put all my working energy into my new job, and it paid off well: I've been enjoying where I work! I forgot all about the commitment I had made for December 2nd.

In November, I began receiving reminders about the talk I signed up to give, just a few weeks out on December 2nd. I procrastinated, and procrastinated, and procrastinated.

At this point I began using mental health tools I've learned since my visit to the mental health hospital. I had to remind myself that public speaking is a terrifying thing for many, but there is no real danger. The fight-or-flight response is simply my body trying to protect me from a non-existent "threat". I also may be an impostor, but whether I am or not isn't even relevant. I'm a person who made a commitment to do something, and to remain in integrity with myself, I must take that on with my best effort. The results of the effort are completely out of my hands.

To push myself to prepare, I scheduled a lunch-and-learn session for the Thursday preceding the conference. I also set aside time at home with my partner to practice the talk.

I prepared, somewhat, and both practice rounds went poorly. But my partner is a wonderful supportive woman, and my coworkers are wondferful supportive people. I received advice, ideas, and encouragement from all and I felt confident I could put something together that was better for Saturday.

And so, the night before the conference, I worked like a caffiene-addled college student to re-work the whole structure of my presentation. I wrote it all out on paper several times and talked to the wall at my desk with my phone's stopwatch running to work out timings. I went to bed around 2am that night, which was exceptionally late for me.

The morning of the conference I ported my notes on paper into a brief slide deck. In my opinion, staring at slides is boring: if someone wants to read a bunch of text to learn something, a book or a web page is a better option than slides. I would rely on my charming looks and personality to teach and entertain my attendees.

My talk was at the end of the day so I spent the rest of the conference enjoying talks from other presenters, chatting with other attendees and spending time with my friends and partner who came with.

I gave my talk, I had a lot of fun with it, and received a lot of positive feedback. I'm glad I did this and even moreso I'm thankful I had the opportunity.

Installing a GraphQL Service on dan schnau dot com

2023-10-20T14:53:05.743Z

As part of an upcoming project, I'll be working with GraphQL. So before starting, I decided to set up a GraphQL API on danschnau.com first.

To accomplish this, I installed the projectgraphql-dotnet and configured it against the danschnau.com blog database.

Thanks to the GraphQL.MicrosoftDI package, as part of the graphql-dotnet project, setting up an API was a matter of one change in the application's ServiceCollection and one in the Application builder.

public void ConfigureServices(IServiceCollection services)
{
           // other services configured....
            services.AddGraphQL(b =>
            {
                b.Services.Register<GraphQLHttpMiddleware<ISchema>, GraphQLHttpMiddleware<ISchema>>(GraphQL.DI.ServiceLifetime.Singleton);
                b.AddSystemTextJson()
                 .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = true) // set to false for production
                 .AddSchema<BlogSchema>()
                 .AddGraphTypes(typeof(BlogSchema).Assembly);
            });
           // other services configured....
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
            // other stuff....
            app.UseGraphQL<ISchema>();
            app.UseGraphQLPlayground();
            // other stuff....
}

Configuring the GraphQL Schema is a matter of mapping the concepts in GraphQL to the application. GraphQL queries are always rooted in a "Query" or a "Mutation" - I think of them as GET and POST in http. In my case, I did not need a Mutation in my Schema, but only a simple Query for the purpose.

using GraphQL.Instrumentation;
using GraphQL.Types;

    public class BlogSchema : Schema
    {
        public BlogSchema(IServiceProvider serviceProvider) : base(serviceProvider)
        {
            // Query = ....
            Query = (BlogQuery)serviceProvider.GetService(typeof(BlogQuery)) ??
                throw new InvalidOperationException();

            // no mutations.
            // Mutation = ....
        }
    }

The BlogQuery defines a graphQL query that can be made, and instructions for the rest of the application to execute, or resolve, the query.

using GraphQL.Types;

    public class BlogQuery : ObjectGraphType<object>
    {
        public BlogQuery()
        {
            FieldAsync<ListGraphType<BlogType>>("blogs", "get all blogs", resolve:
                async context => await blogRepo.GetBlogsAsync());
        }
    }
}

Lastly, the GraphQL package must learn about the types needed. In my case, a BlogType:

using GraphQL.Types;

    public class BlogType : ObjectGraphType<Blog>
    {
        public BlogType() 
        {
            Name = "Blog";
            Field(b => b.BlogId).Description("The id of the blog.");
            Field(b => b.Published).Description("When the blog was first published.");
            Field(b => b.LastUpdated, nullable: true).Description("When the blog was last updated. Null if never.");
            Field(b => b.Title).Description("The Title of the Blog.");
            Field(b => b.Slug).Description("The slug for the blog, used in URL generation.");
            Field(b => b.Content).Description("The Content of the blog, serialized into HTML.");
            Field(name: "URL", expression: b => $"https://danschnau.com/blog/{b.Slug}").Description("The URL for the blog.");
        }
    }
}

The result is that if you visit https://danschnau.com/ui/playground, you get a sample client which can be used to make GraphQL queries for this blog.

Upload and render image in Blazor WASM client-side application

2023-10-07T13:51:59.317Z

Here's some sample code for a blazor client-side component that allows uploading and rending an image. The cool thing about this is that it all happens client-side and allows working with the image in .NET. All that is needed is some interop javascript code, borrowed from this document: https://learn.microsoft.com/en-us/aspnet/core/blazor/images?view=aspnetcore-7.0#stream-image-data

@page "/"
@using Microsoft.AspNetCore.Components.Forms
@inject IHttpClientFactory HttpClientFactory
@inject IJSRuntime JS

<InputFile OnChange="@Upload_And_Render_Image" />

<img id="myImage" />

<script>
  window.setImage = async (imageElementId, imageStream) => {
    const arrayBuffer = await imageStream.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const image = document.getElementById(imageElementId);
    image.onload = () => {
      URL.revokeObjectURL(url);
    }
    image.src = url;
  }
</script>

@code {

    public async Task Upload_And_Render_Image(InputFileChangeEventArgs e)
    {
        Stream ms = new MemoryStream();
        await e.File.OpenReadStream().CopyToAsync(ms);
        ms.Position = 0;
        var dotnetImageStream = new DotNetStreamReference(ms);
        await JS.InvokeVoidAsync("setImage", "myImage", dotnetImageStream);
    }

}

How To Add Controllers To A Blazor Server App

2025-03-29T22:02:06.773Z

Update November 2024

I wrote a much more detailed post about this subject here: https://danschnau.com/blog/how_to_add_a_Blazor_Server_App_to_an_ASPNET_Controller_Web_API

I spun up a new Blazor Server App and wanted to add an API controller, but out of the box it didn't work. It's funny, sometimes the things that you take for granted end up being hard to get past when they don't work how you expect.

I had to do these steps:

In Program.cs, configure Controller routes. This is the "canonical" default:

app.MapControllerRoute("default", "{controller=Home}/{action=Index}/{id?}");
That's basically it. Add a Controllers directory to the Server project, and instantiate an API controller. For example:

    using Microsoft.AspNetCore.Mvc;
    
    namespace MyApp.Server
    {
        [Route("/")]
        [ApiController]
        public class TestController : ControllerBase
        {
            [HttpGet("getdata")]
            public IActionResult GetData()
            {
                return Ok(new { data = new { foo = "bar" } });
            }
        }
    }

After that an HTTP GET to /getdata would return the hard-coded object there.

A List Of Free Programming Challenges You Can Take On Today To Develop Your Skills

2023-09-25T19:09:54.83Z

I Know How To Code But I Don't Know What To Code

With some extra time on my hands these days I am looking for things to code. I notice there are others with similar problems. This is a compiled list of free programming challenges you can start taking on today.

Codewars

Codewars is a site where users both create and solve problems. Solutions are shared and discussed in the app. User solutions are developed, submitted, and analyzed for correctness. Multiple languages are supported. I liked to use Codewars several years ago to test my skills. It can be a great way to make sure your chops with different languages are where you want them to be. They have their own community including a Discord server and discussions board. Codewars is a for-profit adventure, working with companies and educators to provide solutions for developing and recruiting talent.

Topcoder

In my mind, Topcoder is the original programming challenge website. I believe this is the site I tried to access through my America Online Account when I was in middle school. The platform runs on competition, where challenges are posted, and prize money is awarded to developers with winning solutions.

LeetCode

LeetCode is similar to Codewars with the way it presents problems. On LeetCode, "you can use tutorials and study plans to learn fundamental and advanced data structures and algorithms, compete in contests, use guides to prepare for top companies, exercise your problem solving skills by solving real interview questions, and much more.".

Project Euler

Project Euler "is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve."

Project Euler is under a Creative Commons license and not-for-profit. It's a huge list of math-oriented programming problems. It's good practice for any 'math person'. I remember taking a swing at these problems in college and finding them very challenging.

Edabit

Edabit is more straight-to-the-punch coding challenges that run in the browser, similar to Codewars.

Exercism

Exercism is a open-source and not-for-profit code learning platform, where users can either mentor or take on challenges over a large range of programming languages.

Use A RegEx to get the Word Count out of a string in JavaScript

2023-09-25T15:04:35.687Z

I added a 'word count' feature to my blog editor this morning. This is the regular expression to match spaces and line breaks:

/\s/

And in JavaScript:

const count = mystring.split(/\s+/).length;

Will Blazor Replace MVC?

2023-09-23T18:40:38.83Z

Blazor will not simply replace MVC. Blazor is a new technology with its own advantages and disadvantages, while MVC is a tried-and-true technology for building web applications with ASP.NET.

Is Blazor Better than MVC?

The short answer is no, Blazor is not Better than MVC. It's a new technology for a new type of application, and not intended to replace ASP.NET MVC. If you want to build a single-page-application or SPA like experience, and only write with .NET languages like C#, then Blazor is the technology you need. If you want to build a more classic web application experience, then ASP.NET MVC will suit your needs better.

The result of this is that if you want to build a single-page application, Blazor is likely a better choice than MVC for your needs. Blazor WebAssembly, or Blazor WASM, offers spectacular performance gains on client-side applications thanks to taking advantage of WebAssembly.

If you want to build a more classic web application experience, MVC is likely a better choice than Blazor. Blazor is a newer technology but offers potential and has been growing in popularity since 2019.

Is ASP.NET MVC still used in 2023?

It sure is! The blog you're reading this on is powered by MVC. Many enterprise applications run on MVC and they will continue to do so for the foreseeable future. MVC is a time-tested technology that has full-throated support from Microsoft.

MVC is an acronym for Model, View, Controller and it is a way of building out web applications. In short, An HTTP request comes in to the server. The request lands on a Controller, which handles the request and generates a Model. The Model is then sent to a View, which is returned by the server and rendered on the user's page. The View for this page you're reading right now is of type Blog.

MVC is a proven architecture with excellent performance and a large, healthy ecosystem of developers and software packages.

Blazor Hosting Models

Blazor is a technology built for running web applications written entirely in .NET/C#. That is. This is the key difference: in MVC, the web server is running .NET, but you're still running JavaScript in the browser for anything done client-side. With Blazor, everything is run in .NET, both server and client code. Blazor runs .NET code on the browser thanks to WebAssembly, or WASM. Essentially, a tiny version of the .NET framework is sent to the browser, then compiled C# code is sent along with it. This Blazor model is called Blazor WASM.

Blazor can also run entirely server side, with page updates sent to the browser via a SignalR pipeline. This model is called Blazor Server.

In combination with Blazor WASM, and Blazor Server, some code can run on the server, and other code can run on the browser in a hosting model called Blazor Hybrid.

Learn SQL In One Day: The Fastest SQL Bootcamp In History

2023-09-22T19:32:27.313Z

Here we go. I'm going to explain SQL in one sitting. I'm writing this without doing any research, just from my own experience, so do check the facts yourself, and I welcome feedback and will happily make edits. If it doesn't make much sense, well I'm injured and on painkillers today so whatever.

SQL stands for Structured Query Language. It is a long running standard that has been around for decades, long before the internet at least. It's used to query databases. Because it's a standard, there's a lot of overlapping things between different database providers that you can use the same SQL for.

Database Providers

Like Microsoft's SQL Server, Oracle's MySQL, The open source PostgreSQL, open source SQLite, all database providers. They have lots of different characteristics around deploying them and what they cost and who is responsible for them, but they all understand Structured Query Language, SQL.

Tables

SQL is a language primarily for querying Tables of data in databases. Tables are similar to spreadsheets in Excel. As a matter of fact, a lot of database implementations come in to play because an Excel spreadsheet got too big. I've seen it happen first-hand several times in my career. If you have a big spreadsheet and need help making it into a database and a web app, you can hire me.

Anyway, tables are based in Relational Algebra, which is a "math thing" that isn't particularly useful for applications, but if you're making your own database provider, you had better know it well. Data is stored in rows and columns on long-term storage like a hard-disk drive.

Data is (hopefully) normalized over several tables. So, let's make an example table "customer"

CREATE TABLE customer (name nvarchar(255), address nvarchar(255))

You can think of this table as an excel spreadsheet with two columns: one for name, and one for address. Well what if you need to associate more than one address with one customer? The not-so-great way is to make two rows of data in this table for the same customer. A better way is to "normalize" the data and make an Addresses table, and associate the two together. It looks like this when creating the tables:

CREATE TABLE customer (customerid uniqueidentifier, name nvarchar(255))
CREATE TABLE address (addressid uniqueidentifier, customerid uniqueidentifier, address nvarchar(255))

So now you have two tables: customer and address. Customers with one address will have one row in each table. Customers with no address will have only one row in the customer table, and customers with two or more addresses will have a row in the customer table and two or more rows in the address table.

INSERT

How, might you ask, do you insert data into a sql table? Well, you do that with INSERT statements. Let's insert a customer into our tables created above. We can use the newid() SQL method to generate an id, or you can be cheeky and grab one from I Need A GUID!

INSERT INTO customer (newid(), 'app devs r us')

then what if we need to include an address to that customer?

INSERT INTO address(newid(), (SELECT top 1 customerid from customer where name = 'app devs r us'), '123 main street)

This will shove a row into the address table and the associated ids will match up. I had to include a select statement in there to make this example make sense. Bear with me.

SELECT

Retrieving data from SQL databases is what comes up a lot and I feel like I've helped a lot of folks over the years get up and running with this. Allow me to continue with my run down.

get all data from a SQL table

This is the simplest SELECT statement there is.

SELECT * FROM customer

This retrieves all the data in the table

get only one column from a SQL table

We did this in our INSERT example.

SELECT customerid FROM customer

This will return only the customerid row. You could think of it like going into Excel and only copying column 'A' from a spreadsheet.

Get Data Across Tables

This is the real magic of SQL. JOIN. JOINs get crazy complicated but there's one JOIN that has been my bread and butter over the years. The LEFT JOIN. It ties together data so you can see it in one big view, even if it's across tables. Let's use JOIN to get some data from our customers and addresses.

SELECT * from customers
LEFT JOIN addresses
ON customers.customerid = addresses.customerid

This will dump both tables into one view. If a customer has multiple addresses, they'll show up in multiple rows with each address. If a customer has no address, they won't show up in this query at all.

In Conclusion

SQL is very detailed and complicated but if you're just starting to pick it up, hopefully this helps you get started learning SQL.

Syntax to Sawdust: Lessons from Middle School Woodshop

2023-09-20T12:27:57.827Z

My fiancé's job is to provide middle schoolers with hacksaws, orbital sanders, drill presses, solvents, paints, and lumber, and then guide them in the safe usage of these tools and materials.

With my recent funemployment, I've been spending time helping her woodshop students. I learned a lot along the way.

Working In Person Makes A Difference

I've worked remote for half a decade. Going into the woodshop and working with students at first felt like meeting concrete face-first. By the end of the first class, I was excited and exhilarated from communication and human connection. I have to admit that this, delightfully, surprised me.

Being on my feet, moving around, shouting, using body language. It is great fun compared to sitting in the same chair talking flatly into the same headset. My health app on my watch was happy about it too.

Not Everyone Is At 100% All The Time

Some students showed up and worked hard and were at their best one day, and the next they were quiet and lethargic. It became apparent that, just like adults, kids have good days and bad days, and that's nothing to be ashamed about.

Making Something Just Because It's Cool Is Fine

I worked with the kids sanding wood, applying stain, and pounding nails. I began a side project - sanding blocks of wood to be made into bathroom passes - and I'm excited about it. Slinging code is fun and rewarding, but sanding blocks of wood so students can go use the bathroom during class in an organized fashion is as well.

Respect Goes A Very Long Way

I noticed that the students would initially misbehave to test my response. When I could respectfuly correct a student, I observed them putting in more effort in class and showed more respect to both myself and their teacher.

Students who chose not to show respect, including those with prior woodworking experience, were not allowed to participate as their behavior disrupted the rest of the group. It reminded me of the stereotypical 'jerk' ace programmer who looks down on the rest of their team.

A Group Of People Can Get A Lot Done Quickly

In the mornings before classes began, I would prepare work pieces for children (using the mitre saw, pictured above). I'd need to prepare about 150 pieces, and it would take an hour or two. Last night, my fiancé and I wound 150 spools of thread with a power drill and it took more time than the length of the film Anchorman.

But during class, many hands made for very short work. While it takes me time to do the same thing 150 times, 150 students can do it in 20 minutes. It was easy to see that given a large enough group, well divided work, and strong leadership for that group, A lot can get done quickly.

Thank goodness I didn't need to sand all 150 pieces of wood by myself.

Note: While I would love to share photos of the students working on their projects, I will not, in the interest of respecting their privacy.

Work Is A Gas

2023-09-15T16:41:06.44Z

During the postwar expansion of the United Kingdom, a Naval Historian wrote about a phenomenon that explained why governments move at a glacial pace and at the same time, why it can take months to get a Pull Request merged.

In tying to yesterdy's article, "Localhost Doesn't Need To Die, Except Maybe With Venture Capital", I would like to expand on Parkinson's Law and state that work complicates to fill the available time and money.

The three states of matter (I've heard there's also something called 'plasma', but we're going off my high school physics class today) are solid, liquid, and gas. Solids retain their shape, liquids take the shape of their container, and gases expand and take the shape of their container.

Knowledge work is like a gas. it expands to take the shape of its container. It has to be. If it was solid, then knowledge workers would just be on the assembly line. If it was liquid, it would at least be easy to estimate the size of work. But knowledge work has been in the domain of Parkinson's Law since long before it was written about in The Economist in 1955: it takes up everything you give it.

Knowing this, we can rethink how work gets done. Given some arbitrary objective, and one day to do it, I will likely get it done in one day. If I give myself a week, I will take that week. If I give myself a month and a budget of five thousand dollars, I'll take a month and I'll be five grand poorer.

Of course, it is possible it can't get done in one day. The Ideal Gas Law, pV = nRT applies to gases. If I squeeze too much in to too small a space, the amount of pressure and temperature may become too much, and I will burn out.

Since Work is a gas, I think we might all benefit from squeezing work down as tight as we can, and using mindfulness techniques to be aware of the rising pressure and temperature, and use that information to blow off steam while the work gets done in the fastest, smallest container that is practical.

Localhost doesn't need to die, except maybe with venture capital

2023-09-14T19:23:16.893Z

This post is a response to Lucas F. Costa's blog "Localhost will inevitably die", which I enjoyed. I don't think localhost has to inevitably die, and I think it's worth preserving.

In 2008, I ran software from localhost for the first time. I was in the computer lab at my university, a room full of computers and computer nerds. As hard as the custodians worked, the stale smell of nerd sweat never went away. It was a lab full of not-so-powerful desktop computers running Fedora Linux. I was struggling as a computer science student to draw a line between algorithms and data structures, and making anything interesting on the computer happen, like how Facebook was taking off in popularity, having been written with something called php and I guess that guy was getting rich slinging code in college the same as me, except I was losing weight from spending all my money on cigarettes.

That night in the fall of 2008 I wrote an application in PHP supported by a MySQL database. It had no styles, just a table of information I could plug in with the HTML <form> I managed to slap together. I understood the relational algebra that powered the database in theory, but this was the first time I could put some of that power into practice.

I pointed my browser to http://localhost and I believe an epiphany happened. It was the day I became able to create web applications. I could run an app, serve it to my own browser, and make changes to the full stack: database, application, and front end. There was a rush of excitement and I walked home that night through the snow listening to Jay Z and Linkin Park. I had finally learned a practical skill in college.

Keeping localhost alive

I have experienced this problem in the past, where you can no longer run your company or team's application on your laptop anymore. Someone I once worked with put it nicely, saying "I should be able to get on an airplane, crack open my laptop, press a button, and run the whole thing". This was a few years ago, when Wi-Fi wasn't readily available on commercial flights.

As Lucas wrote, localhost dies as applications become bloated and complex. A huge chunk of code becomes a series of microservices, or someone pitches a CQRS implementation to the manager in a place where it doesn't belong. It's not long until technologies like Azure, Kubernetes, and Terraform enter the discussion.

That happens when two things happen: A sufficient, but small, number of technical problems happens with running on localhost, and the company has a huge pile of cash to burn.

If Stack Exchange can do what it does with four SQL servers and 9 web servers, then most any software can run without using cloud tech to rain down a freshly Terraformed copy of the production Kubernetes cluster every Monday morning. But it happens anyway. I've watched the whole thing happen. I've also watched SQL servers chug on and on in a rock-solid application for years and years.

I think it has to do with venture capital funding a bunch of developers without much else to do, or an attempt to just scale as big as possible. I'm not really sure. But in the companies I've worked for that didn't take venture capital, the boring software just chugged on and on. And in the companies that I've worked for that did, localhost did indeed die a painful death.

Boring tech

I'm motivated these days to use the boring tech. If you have a software project that might need to be built good, fast, and cheap, without flashy cutting edge tech, you may want to hire me to make it happen.

Time is of the Essence: Crafting an Image Management Solution in One Hour

2023-09-12T19:09:15.913Z

Today I put together an image management solution for Dan Schnau dot com in about an hour.

Before today, my image management workflow was as follows:

Add the image to the wwwroot/img directory in source code.
Make a commit and re-deploy the DanSchnauDotCom app.
Reference the image in markdown.

Committing and re-deploying with every image became intolerable. It took too long. It wouldn't scale beyond one post per month. These images belong in long-term storage, not in source code.

The solution: Azure Storage and Azure Front Door

First, I created an Azure Storage Account. This took five minutes to create and configure. In the Azure portal, you can drag and drop images. That means I can take screenshots and load them into Azure immediately.

This would have been good enough of a solution, but Microsoft recommends against anonymous public read access to blob data. It's recommended to use Azure Front Door, Microsoft's recommended CDN product, for both security and performance benefits.

I created a Front Door config and tied it to my storage account. Now images are loaded through a cached CDN, and I can use the generated URLs while typing markdown posts, like the one you've read here, and no commits are needed.

I put together an image management solution for my own needs in about an hour. I can help you with yours as well.

A Simple Application of OAuth: Mastodon's API

2023-09-12T15:46:14.337Z

A User Story:

As Dan Schnau,
When I publish a new article on Dan Schnau Dot Com,
I want a 'toot' with the title and a link to the article to be posted automatically,
So that followers of the feed can go read the article.

When this post is published, the DanSchnauDotCom application will publish a 'toot' to my profile on toot.cafe.

In this article are the steps I took to accomplish this goal. If you are looking for someone to implement modern, safe, and secure authentication and authorization flows, you can hire me.

Step One: Register an Application

In order to do so, I first created an app in the development portion of my account at toot.cafe.

Step Two: Get User Authorization

Then, I could use the authorization endpoint to authorize the app with my account at toot.cafe.

The authorization endpoint requires several parameters, which are serialized into the requests query string.

client_id: my application Client Key from step one.
response_type: code
scope: write:statuses
redirect_uri: urn:ietf:wg:oauth:2.0:oob

The client id is the important part for our user story: it informs the API which application, amongst all that might be running on toot.cafe, is asking for authorization. The rest are literals related to OAuth and out of scope for this article.

The serialized request is a big URL: https://toot.cafe/oauth/authorize?response_type=code&client_id=mz3T_application_client_key_goes_here_nnJk&redirect_uri=urn:ietf:wg:oauth:2.0:oob&scope=write:statuses

And opening that URL in a browser logged in to toot.cafe and authorizing the app will spit out an authorization code.

Step Three: Use Authorization Code To Generate A Bearer Token

With this authorization code, we can now make an HTTP POST call to get a bearer token.

We need the client_id and client_secret from step one and the Authorization code from step two.

The request is an HTTP POST to https://toot.cafe/oauth/token with form-data in the request body.

HTTP POST https://toot.cafe/oauth/token
content-type: multipart/form-data

code:KXEcode_from_step_three_goes_hereadk41rtB4
client_id:mz3T4application_client_key_goes_herewnnJk
client_secret:Ul6japplication_client_secret_goes_here3TAILc4Ric
redirect_uri:urn:ietf:wg:oauth:2.0:oob
grant_type:authorization_code
scope:write:statuses

The response:

HTTP 200 OK
{
    "access_token": "oaQC_____________________Crc",
    "token_type": "Bearer",
    "scope": "write:statuses",
    "created_at": 1694018755
}

The access_token in this response is the special secret needed to start making HTTP POST requests to write status updates.

Step Four: Write Some Code To Make the Post with the Access Token

I implemented a new function that would make the http request using the generated authorization code.

    public class SocialService
    {
        private readonly IHttpClientFactory _httpClientFactory;

        public SocialService(IHttpClientFactory httpClientFactory)
        {
            _httpClientFactory = httpClientFactory;
        }

        /*
        * Make an HTTP request to toot.cafe with an authorization code to write a status to toot.cafe/@danschnau about the new blog post.
        * 
        * This is a "happy path" implementation with a hard-coded secret, no logging, and no error handling.
        * In "big kid" applications logging, error handling, and secret management must be implemented.
        */
        public async Task PostToMastodonAsync(Blog blog)
        {
            using HttpClient client = _httpClientFactory.CreateClient();

            client.DefaultRequestHeaders.Add("Authorization", "Bearer oaQ____________________________iCrc");

            // Make HTTP Post Request
            var url = "https://toot.cafe/api/v1/statuses";
            var content = new
            {
                status = $"New Post: {blog.Title} - https://danschnau.com/blog/{blog.Slug}"
            };

            await client.PostAsync(url, JsonContent.Create(content));
        }
    }

In Conlusion

It took more time to write this blog post than it did to implement the functionality discussed in this blog post. The usage of OAuth in this article is narrow in scope, and has much more to do with the protocol than it does with toot.cafe, Mastodon, or the fediverse. I can quickly, safely, and securely implement Authorization and Authentication flows for your business applications using some of the skills I've demonstrated here and you can hire me to do so.

I have been laid off.

2023-09-12T15:43:11.77Z

I have been laid off from my job.

I learned that unexpectedly getting laid off from your job feels a lot like a relationship ending. I experienced a lot of difficult feelings in a short amount of time.

SkyKick laid off 181 employees, about two-thirds of its workforce. My job at SkyKick was among the layoffs.

Instead of immediately taking another full-time job, I will work independently - seeking short-term contracts and building projects of my own. Contact me if you or someone you know may be interested in my services.

Intermittent SSL errors pushing and pulling code

2023-05-30T13:07:25.04Z

For about a year, I've had a problem where git push and git pull from dev.azure.com would intermittently fail with an error like this:

~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443

And then I'd have to re-try, sometimes about a dozen times.

~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443
~#@❯ git pull                                                                                               ❮  
fatal: unable to access 'https://dev.azure.com/dsschnau/_git/codecodecode/': OpenSSL SSL_connect: Connection was reset in connection to dev.azure.com:443

But eventually it would work.

~#@❯ git pull                                                                                              ❮   1
Already up to date.

I searched the web and found a StackOverflow question that suggested a workaround: add a HOSTS file entry to force dev.azure.com to use an ipv4 address. That suggests the intermittent error has to do with ipv6.

I added this entry, and now my console pushes and pulls without SSL failures.

echo "13.107.42.20 dev.azure.com" > C:/Windows/System32/drivers/etc/HOSTS

The Magic P Words

2023-05-05T16:37:55.517Z

When I offer my kids advice, I'm really just giving myself advice. Here are the "Magic P Words" I use.

Planning

I think I offer this Magic P word to myself more than my children. Planning is so important for achieving anything, especially new things.

Sure, Mike Tyson said "Everyone has a plan until they get punched in the mouth.". But it also holds true that Proper Planning and Preparation Prevents Piss Poor Performance.

Please

We all need periodic reminders to use our manners.

Patience

Good things come to those who wait.

Practice

Good things come to those who practice. In practice, it is really the only way to get better at something. The rest is just theory.

I Got an Invitiation to The AI-Powered Microsoft Designer. It's Rad.

2023-04-21T23:45:20.193Z

I got an invitation to Microsoft Designer, an AI-Powered design tool. I tried it out by sampling some save-the-date invitations. The results are really cool.

From a simple prompt, I got some great options to start.

Then Microsoft Designer lets you drill into the image and customize it with a bunch of tools.

Microsoft Designer looks like a killer application of artificial intelligence.

Just a few ideas:

Wedding/Party invitations
School/Church fliers
Application Announcement emails
Classroom posters
Brochure designs

.NET 8 Preview 3: Simplified Output Path format for Builds

2023-04-20T19:31:26.33Z

If you're like me, you're used to finding your .NET build artifacts in /bin and /obj directories inside your source projects. It's been this way my whole career.

In .NET 8 Preview 3, this can be changed to dump the /bin and /obj artifacts into an .artifacts directory instead of the source root.

.NET Manager Chet Husk Writes about it in the comments of 'What's new in .NET 8 Preview 3' discussion.

I'd like to test this little feature out. First, I needed to install .NET 8 Preview 3. It required a system restart.

First, a new console app in a directory testartifactsoutput.

~#@❯ dotnet new console                                                                                                     ❮  

Welcome to .NET 8.0!
---------------------
SDK Version: 8.0.100-preview.3.23178.7

Telemetry
---------
The .NET tools collect usage data in order to help us improve your experience..... *SNIP*

Read more about .NET CLI Tools telemetry: https://aka.ms/dotnet-cli-telemetry

----------------
Installed an ASP.NET Core HTTPS development certificate.
To trust the certificate run 'dotnet dev-certs https --trust' (Windows and macOS only).
Learn about HTTPS: https://aka.ms/dotnet-https
----------------
Write your first app: https://aka.ms/dotnet-hello-world
Find out what's new: https://aka.ms/dotnet-whats-new
Explore documentation: https://aka.ms/dotnet-docs
Report issues and find source on GitHub: https://github.com/dotnet/core
Use 'dotnet --help' to see available commands or visit: https://aka.ms/dotnet-cli
--------------------------------------------------------------------------------------
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring C:\danschnauprojects\testartifactsoutput\testartifactsoutput.csproj:
  Determining projects to restore...
  Restored C:\danschnauprojects\testartifactsoutput\testartifactsoutput.csproj (in 76 ms).
Restore succeeded.

The default behavior is still to build to the /bin directory.

~#@❯ dotnet build                                                                                                           ❮  
MSBuild version 17.6.0-preview-23174-01+e7de13307 for .NET
  Determining projects to restore...
  All projects are up-to-date for restore.
C:\Program Files\dotnet\sdk\8.0.100-preview.3.23178.7\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.RuntimeIdentifierInference.targ
ets(287,5): message NETSDK1057: You are using a preview version of .NET. See: https://aka.ms/dotnet-support-policy [C:\danschnaupr
ojects\testartifactsoutput\testartifactsoutput.csproj]
  testartifactsoutput -> C:\danschnauprojects\testartifactsoutput\bin\Debug\net8.0\testartifactsoutput.dll

Then, we create a Directory.Build.Props file.

~#@❯ dotnet new buildprops                                                                                                  ❮  
The template "MSBuild Directory.Build.props file" was created successfully.

The buildprops file is pretty sparse.

<Project>
  <!-- See https://aka.ms/dotnet/msbuild/customize for more details on customizing your build -->
  <PropertyGroup>

  </PropertyGroup>
</Project>

We add the UseArtifactsOutput flag to the file:

<Project>
  <!-- See https://aka.ms/dotnet/msbuild/customize for more details on customizing your build -->
  <PropertyGroup>
    <UseArtifactsOutput>true</UseArtifactsOutput>
  </PropertyGroup>
</Project>

Now I cleaned up the build by deleting the /bin and obj directories.

~#@❯ ls                                                                                                                     ❮  


    Directory: C:\danschnauprojects\testartifactsoutput


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         4/20/2023   3:25 PM            212 Directory.Build.props
-a----         4/20/2023   3:20 PM            105 Program.cs
-a----         4/20/2023   3:20 PM            252 testartifactsoutput.csproj

And now, a build:

~#@❯ dotnet build                                                                                                           ❮  
MSBuild version 17.6.0-preview-23174-01+e7de13307 for .NET
  Determining projects to restore...
  Restored C:\danschnauprojects\testartifactsoutput\testartifactsoutput.csproj (in 64 ms).
C:\Program Files\dotnet\sdk\8.0.100-preview.3.23178.7\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.RuntimeIdentifierInference.targ
ets(287,5): message NETSDK1057: You are using a preview version of .NET. See: https://aka.ms/dotnet-support-policy [C:\danschnaupr
ojects\testartifactsoutput\testartifactsoutput.csproj]
  testartifactsoutput -> C:\danschnauprojects\testartifactsoutput\.artifacts\bin\testartifactsoutput\debug\testartifactsoutput.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:01.20

Ooh, I see the .artifacts directory in the output there.

The /bin and /obj directories are now in their own /.artifacts folder. Sweet.

~#@❯ ls                                                                                                         ❮  1s 452ms   


    Directory: C:\danschnauprojects\testartifactsoutput


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         4/20/2023   3:26 PM                .artifacts
-a----         4/20/2023   3:25 PM            212 Directory.Build.props
-a----         4/20/2023   3:20 PM            105 Program.cs
-a----         4/20/2023   3:20 PM            252 testartifactsoutput.csproj

~#@❯ ls .\.artifacts\                                                                                                       ❮  


    Directory: C:\danschnauprojects\testartifactsoutput\.artifacts


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         4/20/2023   3:26 PM                bin
d-----         4/20/2023   3:26 PM                obj

Identity Protocol improvements in ASP.NET Core 8

2023-04-10T22:56:48.923Z

Last week, Jeremy Likness discussed improvements to Authentication and Identity features in ASP.NET Core 8.

I wanted to try some of it out, so I first went to install dotnet 8.0.0-preview.2. I think the downloads page looks slick.

OpenID Connect, IdentityServer, and Duende

Earlier this week, I talked about the terms Authentication vs Authorization. Now I'll use this chance to tie the terms to more technical details.

ASP.NET Core, in the past, used a third-party implementation of OpenID Connect called IdentityServer to provide authentication and authorization services. IdentityServer is an implementation of the OpenId Conect protocol, which itself is a layer over the OAuth 2.0 protocol that provides Authentication, which is a protocol for Authorization.

The Authorization story here starts with the OAuth 2.0 Authorization Framework. Oauth 2.0 is a framework for dealing with limitations of client-server authentication. There are a lot of good reasons to not implement client-server authentication. From this developer's perspective, the most attractive reason is that with OAuth, I as a software engineer, don't need to spend the time and money on implementing password security. This is because the OAuth protocol specifies an authorization layer that separates the client and server, enabling third parties to provide Authorization services.

OAuth 2.0 provides an authorization implementation. OpenID Connect provides an authentication implementation. And both are just protocols. That is - protocols that are instructions for software to implement to work with other software that implements the same protocols.

Back to the beginning. Until version 8, ASP.NET Core used a third party implementation of OpenId Connect called IdentityServer. In version 8, this dependency is removed, and developers will be able to pick from IdentityServer or any other number of OpenId Connect and OAuth 2.0 implementations.

Ostensibly, these changes will make it easier to create and ship "simple" auth systems that do things like use social logins - and I look forward to trying them out as they become available.

Authentication vs Authorization

2023-04-10T14:14:51.513Z

Authentication and Authorization (AuthN and AuthZ) are terms that refer to discrete, specific concepts that can easily be confused.

Authentication is the process of proving that someone is who they claim to be.

Authorization is the process of granting access to a resource.

For instance, to buy alcohol, I must be at least 21 years old, as per legal requirements. When I try to make the purchase, the sales clerk will likely request my driver's license. By examining the photo on the license and confirming it to be of me, the sales clerk is performing Authentication. I have presented evidence that I am Dan Schnau, and provided a government-issued document with a photograph and other relevant facts, verifying my identity.

However, at this moment, the sales clerk has not allowed me access to the resource- alcohol. After proving my identity, the sales clerk will perform Authorization. The clerk will verify my date of birth on the driver's license, which will enable them to grant access, knowing that I have already proved who I am (via photo ID) and that I am authorized based on my age.

In summary, Authentication verifies identities, and Authorization grants access to resources based on those identities. It is critical to implement both measures for safe systems.

I asked ChatGPT to write 500 words about the software industry.

2023-03-31T19:21:05.35Z

As an AI language model, it is difficult for me to express opinions or personal bias since my responses are generated entirely based on statistical patterns from the dataset I was trained on. However, I can provide a general overview of the current state of the software industry.

The software industry is one of the fastest-growing industries in the world. It has transformed almost every aspect of daily life, from how we communicate with each other to how we conduct business. The industry has seen exponential growth in the past few decades, with the increasing availability of processing power, deep learning techniques, and cloud computing. Software development has become easier, faster, and more affordable than ever before.

One of the key drivers of the industry's growth has been the rise of mobile devices. With more than 3 billion smartphones in use globally, software developers have had to adapt to the rapidly changing behavior and needs of consumers. This has led to a surge in the development of mobile applications, which have become indispensable for both business and personal use.

Another key driver of the software industry's growth has been the shift to cloud computing. Cloud computing has enabled businesses of all sizes to access affordable computing power and storage without having to set up their own IT infrastructure. This has democratized technology, making it accessible to small and medium-sized enterprises that previously did not have the resources to invest in IT infrastructure.

The software industry has also seen a shift in the way software is developed. The traditional model of developing software has been replaced by more agile approaches such as DevOps, which emphasizes collaboration, agility, and rapid iterations. These approaches have enabled businesses to be more responsive to market demands and to deliver software products faster.

However, the increasing reliance on software has also led to concerns around security and privacy. The rise of cybercrime has highlighted the need for secure software development practices, and companies are increasingly investing in cybersecurity measures to protect their assets and customers' information.

The software industry has also seen a shift in the business model, with more companies embracing open-source software. Open-source software allows businesses to access the source code of software products, customize them to meet their needs, and contribute back to the community. This has led to a flourishing ecosystem of software developers who share their knowledge and collaborate on projects.

Finally, the software industry is undergoing a shift towards automation and artificial intelligence (AI). AI has the potential to transform the way we develop software, making it more efficient and effective. AI-powered tools can help identify bugs and optimize code, freeing up developers' time to focus on more complex tasks. However, there are concerns around the impact of automation on jobs, and the industry must find a way to balance the benefits of automation with the need to protect jobs and skills.

In conclusion, the software industry is in a state of constant evolution. As technology continues to advance and consumer behavior changes, software developers must adapt to stay ahead of the curve. The industry's growth and increasing importance in almost every aspect of daily life are indicative of the potential it holds for the future. However, the industry must also address the challenges it faces, such as cybersecurity and the impact of automation on jobs. Overall, the software industry is a vital and exciting industry, and its future is full of promise.

Rules for Overcoming Worry

2023-01-25T16:52:32.023Z

A few years ago I visited a used book store in Seattle. It had several cats hanging around with the customers, which was pretty cool.

I found a copy of How To Stop Worrying and Start Living by Dale Carnegie, of "How to Win Friends and Influence People" fame.

I bought it, and it's been a great book to keep around when I get stressed out.

One of the exercises in the book suggests creating your own rules for overcoming worry. I wrote my answers down and have copied them here.

Rules for Overcoming Worry

Remember that every moment is new. Past performance is not indicative of future results.
Meditate. Breathe relaxation and loving-kindness into your muscles, from head to toe.
Remember what your mother told you when you were a stressed out child (and has been so right about): "Most of the things you worry about will never even happen".
Focus on the present day in front of you. The distant future is of no concern. As Apollo Creed told Rocky Balboa as he trained to fight Clubber Lang: "There is no tomorrow!"

I put a lot of energy into stayling relaxed these days. I know that being stressed out will not only not help but rather it will harm me.

Affiliate notice

This page contains Amazon affiliate links.

Good Software Engineers are Business Analysts Too

2023-01-20T18:31:35.77Z

Good software engineers have to understand the business they're working in.

If they don't, they're at the mercy of business analysts and project managers to explain what to do.

Some of my most successful moments in my career have been when I've taken on a role of business analyst and gone directly to the source for information on what needs to be built for the business.

In other words:

You gotta write code, and be this person too.

ChatGPT Is at the Peak of the Hype Cycle

2023-01-19T16:01:39.7Z

ChatGPT is at the peak of the hype cycle.

Yes, let's deploy to production.

2022-12-18T01:35:51.223Z

A friend (a geniuine friend, who I truly respect, both personally and professionally) shared this video with me the other day.

The video is pretty funny. But it touches on something I'd like to see change.

If I'm a paying customer for some software in development, I'd much rather have some partially working software that I paid for than nothing. So management will push to ship something.

If I'm a manager, I want to show my customer that we're working for them by delivering deliverables on a schedule.

If I'm a software engineer, and I shit on those trying to buy and sell software just because the software isn't perfect, then I'm not doing my job.

Perfection is an illusion. Perfectionism is a mental health issue.

Yes, let's deploy to production. Deploy it and watch where things go wrong. Improve from there. You'll never do agile right, but you can be agile. Without deploying to production, and failing, there won't ever be any real success.

Find your Application Insights node from the Instrumentation Key with Azure CLI

2022-11-30T14:06:54.787Z

I had an instrumentation key but I didn't know what instance of application insights telemetry was getting pumped into.

After some fiddling I got a one-line command in Azure CLI to get an Application Insights instance from an instrumentation key.

az graph query -q "Resources | where properties.InstrumentationKey =~ '00000000-0000-0000-0000-000000000000'"

The command spits out a JSON blob of information about any instances that match the query.

You'll Never Do Agile Right

2022-11-23T19:39:27.31Z

In the article for Agile Software Development, there are six thousand, eight hundred words and over 100 references.

The Agile Mainfesto is 73 words. Gobs and gobs of software has been written to "do agile". Every software shop I've encountered in the last decade has told me they use an agile software development process. Being an "Agile coach" is an entire career.

But the whole manifesto is just not all that.

The entire body reads as follows:

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

Individuals and interactions over processes and tools

Working software over comprehensive documentation

Customer collaboration over contract negotiation

Responding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more.

That's it. Focus on relationships with people, and actually solving problems.

Moreover, the Manifesto ends with a sentence to weasel out of any actual firm stance. The other stuff is also valuable.

You'll never do Agile right, because there's no way to prove that you're doing it right. Don't make user stories and have retrospective meetings just because it says to do so in some book or by some coach.

Do what works for whatever your situation. Just make sure your values and priorities are in order. That's the whole manifesto.

INVEST in Good User Stories

2022-04-20T18:24:44.183Z

Software isn't always complicated.

But when you work on big, complicated software, with lots of people, it does get complicated.

It's easy to get stuck in the mud with big software and lots of people working remotely.

So communication is very important. Planning your work is very important.

I think it's very corny. But I have to admit that writing good user stories is important if you want yourself and your team to be effective.

Assuming you're a software engineer.

I asked SkyKick's resident expert on the subject: "What Makes a good User Story?" and I got back the INVEST criteria.

Independent. The story doesn't have dependencies or prerequisites.

Negotiable. The story isn't so rigid as to be brittle. Details can change and things can be rewritten. The important part of the story - the actual value of it - remains.

Valuable. Your Tech Debt Story Doesn't Matter If It Isn't Valuable To The Stakeholders. Stories completed need to be delivering value. We aren't getting these fat paychecks for nothing.

Estimable. If you have no idea how much effort it will take to get the work done, not even a reasonable guess, the story is worthless. We're trying to plan our Big Kid work at our Big Kid Company.

Small. If it's so big you can't get it done in a couple of days, it's not a story. It's an Epic, and multiple smaller stories need to be created under that epic.

Testable. You gotta be able to prove if it worked or not. Full stop.

If you gloss over these and write crappy user stories at work, you're going to have a bad time.

I Went to a Mental Health Hospital

2021-07-03T21:13:00.163Z

Shortly after I wrote the "Suicidal Ideation" post, I had a really really bad day.

I had told my therapist that I was thinking about suicide.

I had told my therapist that I had a specific plan.

My therapist asked for my wife's phone number to contact in case of emergency.

That afternoon in February, I locked myself in the bedroom.

It was enough to call it an emergency.

Police entered my home and took me away in handcuffs to a hospital of my choosing.

I spent two nights on suicide watch in a hospital gown in a stripped-bare room.

I was then taken via ambulance to a mental health hospital. I spent another five nights there.

At the mental health hospital, I began taking antidepressants and participating in group therapies.

I made a few friends there.

After I left the mental hospital, I began telling friends and family what happened. Everyone was supportive. My relationships with my friends and family strengthened.

The antidepressants have been effective for me. I consult with a psychiatrist regularly about adjusting the medications.

I still meet with my therapist regularly.

I'm glad I'm here today.

Two Rules of Thumb for Day-Job Programming

2021-06-24T19:26:42.62Z

Rule #1: Never commit code you haven't run at least once, no matter how small or simple.

Rule #2: Have a plan, and execute that plan, for verifying changes and fixes when they go into production.

npm errors with node-sass, node-sass deprecated, drop-in replacement available

2021-06-23T15:17:59.633Z

The node-sass npm package has given me problems on various projects at various companies over the years. It's a js wrapper around a python implementation of Sass, a CSS pre-processor. Or maybe the python is there to run a ruby script, or something like that. I'm not really sure, I just want the package I npm install'd to work.

Errors usually look something like this: Error: node-sass@4.13.0 postinstall: node scripts/build.js

The first thing that usually happens is that it works on my machine but not my build machine, or vice-versa. That's usually resolved by making sure versions of node and npm are up to date on all invested parties.

Then I usually get the error locally complaining about Python not being available/not in the right place.

But today, I found out that node-sass is deprecated. The replacement is just sass, which is a Dart implementation of sass.

npm uninstall node-sass

npm install sass

Done. A quick smoke test and ready to deploy.

Truthiness and Falsiness in JavaScript

2021-06-19T23:41:08.313Z

JavaScript has ‘truthiness’ and ‘falsiness’.

Things that are “falsey”:

null
undefined
false
0

Things that are “truthy”

function() {}
'' (empty string)
'any other string'
true
1 (or any number, apart from 0)
[] (empty array)
{} (new object)
Object

Suicidal Ideation

2021-02-23T22:00:32.31Z

This is not a cry for help. I’m getting help and I’ve been getting help.

I have a depressive mind. When I woke up last Saturday, horrible thoughts were gnawing at me. I scribbled them into my planner.

The note reads as follows:

There’s no good reason for me to exist. If I died, everyone would be better off.

The kids would no longer have a crazy Dad. Heather wouldn’t have to deal with me and she’d get lots of insurance $.

My friends would be fine. I’m a drag on them anyway. Work… it’s laughable to think anyone would even notice.

I’m a drag on the world and it’s in everyone’s best interest if I killed myself.

This is not my real mind. At least, it is not my whole mind. It is a part of it. It is a part of my mind that is trying to protect me, but it is attacking the wrong things, like an autoimmune disease.

Poor mental health is something I cope with along with roughly 1 in 10 of other American Adults.

The Relationship Between Docker and Kubernetes

2021-01-28T03:18:46.487Z

I’m learning container tech on the fly at work.

This is how I understand the relationship between Docker and Kubernetes. If I’m wrong, or learn more, I’ll write an update post.

Docker is the tech that makes ‘containers’ like a shipping container. It’s a popular one, but not the only one. The containers fit a specification so they’re interoperable.

Just like shipping containers, Docker containers are portable, small, and work anywhere. On a boat, on a truck, in a loading dock, on a crane.

You don’t need Kubernetes to run a container. You might be a truck with a single Docker container on your bed.

But if you’re a cargo ship, with a huge pile of containers, you need Kubernetes. It’s software for managing a constantly changing pile of containers.

How To Reference and Focus a DOM Element from Blazor Component Code-Behind

2021-01-23T13:43:36.17Z

The Direcive Attribute @ref can be used to refer to a specific DOM element.

There’s also a convenience method FocusAsync for focusing an input element.

In my Blazor Markup:

    <input @ref="addNameInput" type="text" placeholder="Enter your name here" />
    <button class="btn btn-primary" @onclick="AddNameAsync">Add your name</button>

And in my code-behind:

protected ElementReference addNameInput { get; set; }
protected async Task AddNameAsync()
{
    // focus the input and return if addNameInput is empty
    if(string.IsNullOrWhiteSpace(_nameToAdd))
    {
        await addNameInput.FocusAsync();
        return;
    }
}

How To Move Blazor Component Code into a Code Behind

2021-01-23T13:07:43.6Z

Here’s the steps to getting a Blazor Component’s code out of a @Code block and into it’s own file.

It doesn’t take much to make a one-file blazor component hard to work with since there’s markup and logic in the same file.

Let’s call our example component ExampleComponent.razor.

In the same directory as ExampleComponent.razor, add a file ExampleComponent.razor.cs. Visual Studio should nest it appropriately.
Change the new class name from ExampleComponent to ExampleComponentBase and have that class inherit from Microsoft.AspNetCore.Components.ComponentBase.
Cut/Paste everything from the @code block into the body of the ExampleComponentBase class.
Tell the Page about it’s new base class. At the top of ExampleComponent.razor, add @inherits ExampleComponentBase before the @page directive.
Fix Dependency Injection. Instead of using the @inherits directive in a Razor page, add an [Inject] Attribute and a {get;set;} to injected dependencies. For example, @inject NavigationManager NavigationManager in a Razor Component would become [Inject] NavigationManager NavigationManager { get; set; } in a code-behind.
Change any private fields accessed by markup to protected. They will need to be protected instead of private since the Razor Component markup is now a sub-class of ExampleComponentBase and thus cannot access private fields.

10 Years as an Impostor

2021-01-23T11:54:59.673Z

For me, this February will mark 10 years of collecting a steady paycheck in software engineering working on “boring business software”.

I’m in my 30s. I have a four-year degree in Software Engineering from a university that shows up on this list.

Ten years ago, my salary was $42,000. I’ve tripled that salary and then some.

Several times I’ve quit one job for a better one. I’ve never been fired from a job.

I’m a cis white male. I live in the Midwest USA.

If anyone working in our industry might not feel like an impostor I imagine they might look a lot like me.

But I feel like a fake, a fraud, just waiting to be found out I don’t hold all the cards, frequently.

I don’t have anything new to say about impostor syndrome. I just won’t spend another decade being ashamed of it.

I set up a Pi-Hole because of the Pandemic

2020-05-29T23:06:40.197Z

Because of the pandemic, my sons have been using laptops a lot for gaming during the day. Their machines don''t have adblockers. I figured this was a good time to set up pi-hole.

I used Raspian imager to image an SD card. I then plugged in the SD card, hooked up the raspberry pi to my monitor/mouse/keyboard at my desk and ran through the Raspbian setup wizard.

Then I powered down the Pi and moved it to the entertainment center and hooked it up to the router and (temporarily) TV and a mouse/keyboard.

Pi-Hole provides a ''one-command'' installer script:

curl -sSL https://install.pi-hole.net | bash

There were a few prompts in the install script, I accepted all the defaults. One thing I wonder about is using an ''upstream'' DNS server apart from Google. I left it at Google, I''ll look into the other DNS servers another time.

That was up and running and I thought I was ''done'' so I tested loading people.com on my phone (while connected to Wi-Fi) and ads still showed up. I realized I forgot to configure the router to use the new DNS server.

So I looked up instructions for how to do that on my router and did so, it was pretty easy.

Pi-Hole provides a web interface, which worked without issues, but I wanted to be able to ssh into the pi-hole in the future so I don''t need to connect it to the TV. I found out that Raspbian lets you do this with a few points-and-clicks. Then I could ssh from any laptop in the house on the wifi. I took the HDMI cable, mouse and keyboard out of the pi and the project was done.

Setting up Pi-Hole was really easy. The whole bit was one in about an hour and the kids were back to gaming in no time.

Discovering nuget.exe Versions with tools.json

2020-04-13T20:38:59.36Z

While updating my build failed with an upgrade from ASP.NET Core from 2.2 to 3.1. I was using Azure DevOps for my build.

I was getting a funny error:

##[error]The nuget command failed with exit code(1) and error(C:\Program Files\dotnet\sdk\2.2.110\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.TargetFrameworkInference.targets(137,5): error NETSDK1045: The current .NET SDK does not support targeting .NET Core 3.1.  Either target .NET Core 2.2 or lower, or use a version of the .NET SDK that supports .NET Core 3.1.)
##[error]Packages failed to restore
Finishing: NuGet restore

It turned out my build was set to an old version of NuGet, which has seen several updates for .NET Core.

I also learned Microsoft''s NuGet team publishes a json file detailing release history and preview releases at https://dist.nuget.org/tools.json. More detail on the contents of the file at docs.microsoft.com.

Implementing Single-User Administrator Authorization with Azure AD in ASP.Net Core 3.1

2020-04-12T04:24:55.413Z

Until now, this blog was entirely a read-only site. Content is stored in a database, and the app reads from that DB, but there was no code for writing to the DB. In order to update content, I''d manually write SQL queries. I needed to be able to secure some features of the site so I could get away from that practice.

Here were my goals for this:

Save no user data in the app.
Use my Mirosoft Identity (the same one I use on my Xbox) to log in.
Only allow me to Authorize.

I worked off this helpdoc at docs.microsoft.com. It links to a sample project I could use as a reference, which was useful while troubleshooting.

Install Dependencies

Step 1 was to install Nuget package Microsoft.AspNet.Core.Authentication.AzureAD.UI.

Create new Azure AD App registration

To use Azure AD auth, you need to create an App Registration. I did mine point-and-click in the Azure Portal.

More info on how to do this at docs.microsoft.com. By the end of it, I had a TenantId and a ClientId. I also had to make sure my redirect urls were correct - I needed danschnau.com/oidc-login for prod and localhost:8888/oidc-login for local development.

Configure Things in your app

In my ASP.NET Core 3.1 app, I plugged in a few settings into my appsettings.json. These were copied from the sample project.

"AzureAd": {
   "Instance": "https://login.microsoftonline.com/",
   "Domain": "[Enter the domain of your tenant, e.g. contoso.onmicrosoft.com]",
   "TenantId": "TENANT_ID_GOES_HERE",
   "ClientId": "CLIENT_ID_GOES_HERE",
   "CallbackPath": "/signin-oidc"
},

Update `Startup.cs`

`Configure` Changes

In Configure, I added app.UseAuthorization() and app.UseAuthentication().

// This method gets called by the runtime. Use this method to configure 
// the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    // snip

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseCookiePolicy();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints => { /* snip */ });
}

`ConfigureServices` Changes

In ConfigureServices, I added a few things.

I changed services.ConfigureMvc() to instead to a bit of Authorization configuration:

services.AddMvc(options =>
{
    var policy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();
    options.Filters.Add(new AuthorizeFilter(policy));
});

I also had to call services.AddAuthentication():

services.AddAuthentication(AzureADDefaults.AuthenticationScheme)
    .AddAzureAD(options => Configuration.Bind("AzureAd", options));

Then I had to call services.AddAuthorization, specifying that the only way to be authorized is to have a claim of my email address.

services.AddAuthorization(options =>
{
    options.AddPolicy("adminpolicy", o =>
    {
        o.RequireAssertion(authorizationHandlerContext =>
            authorizationHandlerContext.User
            .HasClaim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress", "dsschnau@gmail.com"));
    });
});

It took a bit of trial and error to get that working.

Add `[AllowAnonymous]` To Public Controllers

This blog is a pretty vanilla MVC app. All the Controllers that service public-facing pages got the [AllowAnonmyous] tag put on their clases.

[AllowAnonymous]
public class HomeController : Controller

Secure A Controller

Then I could force a Controller to lock down access to only me:

    [Authorize("adminpolicy")]
    public class AdminController : Controller

That was it! All done.

Closing Thoughts

This all worked well, taking 2-3 hours to implement this. Having examples, well-written documentation, and helpful error messages, I was never stuck troubleshooting for too long.

There''s more I'd like to do around Authentication/Authorization on Dan Schnau Dot Com in the future - adding the ability to leave comments comes to mind.

If you have feedback, questions or advice - email me at dsschnau@gmail.com.

Running NUnit 2 Tests in Visual Studio 2019

2020-01-02T00:54:39.927Z

I encountered an issue the other day where I was unable to run unit tests in the Visual Studio 2019 Test Explorer.

The tests would just show up as 'skipped' in the Test Explorer UI, and the Test output window would say something to the effect of:

[Informational] Executing test method 'MyProject.UnitTest1.Main'
[Informational] ------ Run test started ------
[Warning] No test matches the given testcase filter `FullyQualifiedName=MyProject.UnitTest1.Main`...
[Informational] ========== Run test finished: 0 run (0:00:03.6212841) ==========

The test project used NUnit 2 for it's testing framework.

After searching the web, I found out I could add a different NuGet package that enabled running the tests from the Test Explorer.

It's called NUnitTestAdapter. After installing that package and rebuilding the project, I was able to run my tests. Though I haven't tried it, it looks like there's a separate package for running NUnit 3 tests: NUnit3TestAdapter

Promise.all()

2019-08-17T19:06:29.67Z

In JavaScript, you can use Promise.all() if you need to wait for a few promises to complete before moving forward in a routine.

var p1 = getData(); // getData returns a promise with some data when it completes.
var p2 = 42;
var p3 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, 'a fake promise')
});

Promise.all([p1, p2, p3]).then(function(promiseResults) {
    console.log(promiseResults);
    // promiseResults will contain an in-order array of the results of `getData()`, 42, and 'a fake promise' 
});

For more information, check out the Mozilla Developer Network.

An Atom feed on DanSchnau dot com

2019-07-29T04:01:40.067Z

As of yesterday this blog supports syndication by Atom feed. You can use this link to connect the feed to a reader.

I took joy in writing the code for this feed. Coding by requirements of a web standard is a much different experience than that of business-oriented User Stories.

Atom is a 'publishing format' which is a contract that says "I'll supply my information in a specific form, so external applications will know how to read it."

It's not common for applications to interoperate well anymore. Wouldn't it be nice if your Facebook feed also could read your Twitter feed?

Anyway to publish with this format, you publish an xml file formatted a specific way, then feed readers can read it. That's it.

My implementation isn't much more than a bunch of XDocument calls. Here's the gist:

I used some random samples around the web to get started, including this one on Wikipedia. I found that w3.org hosts a validator for validating RSS and Atom feeds. That was very useful.

How to Change which Identity Visual Studio uses to Authenticate with Azure

2019-07-21T22:05:12.593Z

I was developing an app locally on a different laptop than usual. When it started it would fall over returning 502 errors. I saw in Visual Studio's debug output this error:

Exception thrown: 'Microsoft.Azure.Services.AppAuthentication.AzureServiceTokenProviderException' in System.Private.CoreLib.dll

The error was caused because my app uses a Key Vault instance on a different subscription. I had already signed into Visual Studio with the correct identity, but there's another step to tell Visual Studio 2019 which identity to use when authenticating.

As I found in The Azure/Key Vault docs, The menu is under Tools > Options > Azure Service Authentication.

Working Remote is Awesome

2019-07-13T11:51:35.787Z

This March I began a new job at SkyKick. SkyKick is a world-class startup and I couldn't be more excited to be a part of their team, and that's in no small part due to that they've trusted me to work remotely from my house in metro Detroit.

At SkyKick, I spent my first two weeks at the office in Seattle, to make onboarding go smoothly. Then I flew back home to DTW with my new work laptop in hand.

Working remote took some getting used to. I was uncomfortable without having anywhere to go on my first remote day so I took a picture of my desk with a "thumbs-up" in front of my phone and posted it to Slack.

Three months in, I'm emphatically happy with this working arrangement.

I believe that as it becomes more 'normal' to work from wherever, the stigma around it will fade away.

The rest of this post details some of my remote experience so far.

Be intentional about talking to people.

Just like back in the days of Barrens chat, my communications are now entirely through typed text, some colorful avatars, and occasional voice chat.

That means if you want to talk to someone, you gotta talk to them! You can't idly hang out in the kitchen drinking coffee hoping that the person you wanted to speak with strolls by, just so you don't have to feel like you're bothering them at their desk.

Send messages! Ask people how they are! Schedule 1-on-1s! Put the onus of "Can't talk right now, I'm busy" on the other person - you have no idea how busy they are because you can't look over their shoulder.

Distractions

I live with my wife and three children. my school-age kids are home for the summer. The house is a bit chaotic day-to-day, and programming is a job where you frequently need to quietly focus on something.

Fortunately I'm not the first to encounter this issue, and strategies for handling work-at-home have been well discussed.

Have a specific room that you work in
Set 'office hours'
Set clear boundaries with family members or co-habitants
Be transparent with your team
Use your webcam liberally
Invest in a good headset with a good microphone

The most important to me has been the headset headphones. I bought a (used) Steelseries Arctis Pro with GameDAC and I couldn't be happier with the purchase.

Writing skills

Most of my working communication is now written. I think it's just as important for a software engineer working remote to practice writing along with programming.

My favorite book on the subject of writing is On Writing Well By William Zinsser. It's a great book both for technical advice and inspiration to write well. I'm not setting out to be a writer by trade, but I came out with a greater respect for the craft after reading this book.

Links talking about Remote Work

People are talking lots about remote work. Here's a list of links I collected over the last few months:

Jessica Stevens @ Fast Company: Why Remote Work Isn't Going Away Anytime soon

Sarah Sunday @ 8thlight: Remote Team Workflows

Quuu: Remote working – Bringing Sanity to Mind & Lessons Worth Learning

Upside.fm: The “Future of Work” is Here… So Why Aren’t More Companies Remote-first?

This blog is a nice love letter from a guy working successfully in a co-working space: Chris Salzman: On Workantile's 10th Birthday

Julia Evans has written several posts on the subject of working Remotely for Stripe:

Google shouldn't Be A Verb

2019-04-02T14:46:47.503Z

"Google" is a company built on a search engine. It isn't a verb.

In 1998 Larry Page wrote in an email "Have fun and keep googling!". It is the first recorded usage. Of course he would would want you to use it as a verb.

But when you use "Google" as a verb for "search the web", there is a problem. It builds into language an assumption that Google is the One True Search Engine. There can be no other web search engine, because the word for "search the web" is Google.

That isn't true. Google is a good search engine, sure. But it isn't perfect for every search every time.

I use DuckDuckGo. It has a better privacy story and tooling. Microsoft Bing has a rewards program. Wiby Is a search engine for "classic" websites. Wolfram Alpha will give precise information that you won't find on Google.

Search engines are amazing modern technologies we didn't have two decades ago. They shouldn't be shouldered out by language. So the next time you tell your friend something you looked up with Google, let them know you searched the web for it.

LocalStorage, The unary operator and strict equality in JavaScript

2019-03-16T02:45:27.02Z

My stance on JavaScript strict vs. type-converting comparison (double vs. triple-equals) is to always use strict equality. But the other day this tripped me up.

I had a number stored in local storage and I wanted to check it against a constant number.

But, the check failed even when the numbers were the same. I then learned that everything stored in local storage is stored as as string. your data).

I put the unary operator + in front of the value read out of local storage, and the problem was resolved.

gotcha: Compiler error CS0656 when using Dynamics in a .NET Standard project

2019-03-02T00:10:00Z

This afternoon I'm experimenting with Dapper, a micro-ORM used by Stack Overflow. The most straightforward way to query with dapper is to get a list of Dynamic objects. But when I went to read some data out of a table I got this compiler error.

CS0656 Missing compiler required member 'Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create'

I had to search the web for the cause. It turns out you need to install two NuGet packages to work with Dynamics:

I got tripped up on this because I thought Dynamics were just part of the features of C#, so I wouldn't expect to require a nuget package to use them. But then things like System.Linq are their own packages, so I guess that's the way things are here.

Four Pillars Of Object Oriented Programming

2019-03-02T00:00:00Z

Abstraction
Encapsulation
Inheritance
Polymorphism

When I was in college, and for my first few years of Seriour Business Programming Jobs, these four concepts seemed Big And Scary, Like I Would Never Understand Them.

If you work with an object-oriented language, it's worth knowing them intentionally. You can be more effective if you're able to distinguish and apply these with explicit reasons.

It's possible that you use them without realizing it.

Abstraction

Here's when you need an abstraction: If you ever find yourself thinking "I'm writing the same code over and over with only small changes for different types. It would be cool if I could write this routine once and use a more generalized type rather than a {String, Int, Object}|{Cat, Dog, Mouse}{XmlDoc, JSONDoc, BinaryStream}."

When you do so, you're using an Abstraction.

Encapsulation

Most objects are complicated enough that you should hide details that the object needs in order to work correctly, but no other objects should ever need. Hide those fields and methods with Encapsulation!

Inheritance

Inheritance is closely related to the concept of Abstraction. It amounts to pushing common features of a class into a base class. Writing the same code over and over again across classes? Make the method once in an Abstract class. Then, in the places where you were repeating code, you can inherit from the base class, getting all the functionality with none of the repetition.

Polymorphism

Ever notice how you can add `ints`, `floats`, and `doubles` together? That's polymorphism at work. Polymorphism is the act of different types in a language working with each other because they have a common interface, such as the '+' operator in our example.