Introducing a new open-source project called sabledocs, which is a static documentation generator for Protobuf and gRPC contracts.
How to include protobuf contracts consisting of multiple files in .NET Core projects.
This post gives an overview of the various ways to override configuration values in ASP.NET Core integration tests.
An overview of implementing shadow mirroring with Envoy, to safely test a service with real production traffic without affecting the end clients.
An overview of the challenges and solutions for implementing graceful termination when using ASP.NET Core in Kubernetes.
An introduction to using Envoy as a load balancer in Kubernetes, and configuring various load balancing algorithms.
Varnish can gracefully fall back to cached values in case our backend is down. This post describes how we can handle 5xx errors this way.
A quick introduction to setting up automated code style checking for .NET Core projects with StyleCopAnalyzers and editorconfig.
Introducing a simple Visual Studio Code extension for saving pieces of code, and later easily insert them into source files, intended for coding demos.
This guide shows how to generate and publish API documentation for a .NET Core library, using DocFx, GitHub Pages and AppVeyor.
How to secure an ASP.NET Core application with Firebase Authentication by verifying the access tokens in the Authorization header.
Chasing down why ASP.NET Core applications might use unreasonably much memory in Kubernetes, and how to it can be mitigated.
The first request to an ASP.NET Core API is always slow. This post shows a way how to warm up our application before deploying it to production.
Static state in an ASP.NET Core application can cause problems when running subsequent integration tests. In this post we take a look at how to solve this.
This post describes setting up coverage generation with OpenCover for a .NET Core project, and shows how the report can be uploaded to Coveralls.
Second part of an exercise illustrating how F# can provide an elegant solution to some of the challenges we face when designing data models in OO languages.
A simple data model exercise illustrating some challenges we encounter when designing domain models in object oriented programming languages.
Taking a look at how the composition of the Kleisli category can be implemented in C#, and what are the limitations we have to face in type inference.
Two possible problems (and their solutions) we can run into when registering objects with various lifecycles with the DI container of ASP.NET Core.
A simple approach to update the expiry of all the documents in a Couchbase bucket, using a view and a custom updater script.
An introduction to get started with web development in F#, using the Suave web framework on .NET Core.
An introduction to get started with web development in F#, using ASP.NET Core.
An introduction to get started with web development in F#, using Suave.IO on the classic .NET Framework.
An introduction to get started with web development in F#, using ASP.NET on the classic .NET Framework.
Instructions to get started with F# web development using either ASP.NET or Suave.IO, targeting the .NET Framework or .NET Core.
Programmatically refreshing a browser tab from an application can be done with a WebSocket connection. This post describes how to achieve this in Golang.
This post gives and Introduction to setting up a continuous delivery pipeline for a Golang-based project in Travis-CI.
This post gives and Introduction to setting up a continuous delivery pipeline for a Golang-based project in AppVeyor.
Downloading artifacts for a particular GitHub release is easy, but to download artifacts from the latest release we need some extra steps in our scripts.
A summary of my experiences at NDC Oslo 2016, and excerpts from the sessions I found the most interesting.
It can come handy to manually match a request path to route templates, and extract the arguments. This post describes how it can be done with ASP.NET Core.
Stubbery is a library for creating and running Api stubs in .NET. The post shows how it can be used to stub service dependencies during integration tests.
The slightly changed TRX generation in vstest.console.exe causes SpecFlow to generate empty HTML reports. This can be fixed with a custom Logger.
A guide about how to migrate a Ghost blog using SQLite to PostgreSQL running on Openshift.
A simple approach to evaluate DataAnnotation validation attributes not only on model properties, but on the action method parameters as well.
Some random tips and tricks I have learnt during spending a couple of weeks with getting started with ASP.NET Core.
Implementing client-side compression for Couchbase is pretty simple. In this post we take a look at what this costs us and how significant the benefits are.
This blog post describes some quirks and issues with Couchbase Server which can make getting started with it more difficult and troublesome.
GetHashCode plays an important part in the implementation of a hash map. We should be familiar with it when using a custom type as a Dictionary key.
A look under the hood of Dictionary<TKey, TValue>, an overview of how the hash map data structure has been implemented in the .NET Framework.
An introduction to how a hash table works, which is the foundation of the key-value stores implemented in many environments.
There are different ways to store state during SpecFlow tests, and all of them have benefits and drawbacks.
Glimpse is not fully supported for the Web Api, but it can still be a valuable tool.
How to create a shortcut in Visual Studio to attach the debugger to a specific process.