Coding Militia

Sometimes it's just better to load "all" the data

Sun, 15 Feb 2026 17:00:00 +0000

A quick post on adapting your approach to the problem at hand, not just following the same ideas indiscriminately.

On professionalism, professional pride, career and ambition

Wed, 21 Jan 2026 19:25:00 +0000

An half-rant, half-reflection on the importance of professionalism, taking pride in one’s work, and the role of ambition in career growth.

Adopting Problem Details for HTTP APIs

Tue, 15 Jul 2025 15:00:00 +0100

Time for a quick post about Problem Details, and how we adopted it at work, in a way that’s actually useful.

How I've been building APIs and microservices lately (feat. C# & .NET)

Wed, 11 Jun 2025 08:30:00 +0100

This post is all about how I’ve been building APIs and microservices lately (using .NET and C#), what’s been making me productive, and how my approach has evolved over time.

Kubernetes API powered resource discovery (feat. K8s C# client)

Sun, 27 Apr 2025 19:40:00 +0100

Have you ever felt the need to automate the discovery of some information within a distributed system? Turns out, the Kubernetes API makes it surprisingly simple to do so.

Care about the domain, not about implementing all the patterns and principles under the sun

Mon, 16 Dec 2024 19:20:00 +0000

Time again for a rant adjacent post, on this occasion, about building applications following some domain-driven design ideas.

Introducing OutboxKit

Tue, 03 Dec 2024 08:45:00 +0000

After talking about the outbox pattern so much, and implementing it from scratch a few times in a few different projects, finally figured it was high time for me to build something I could reuse.

Keeping an eye on cache hit ratio (feat. FusionCache, OpenTelemetry & friends)

Sun, 17 Nov 2024 18:15:00 +0000

In this post, we’ll take a very quick look at how to use the awesome FusionCache library, and how to observe its impact on our services.

Testcontainers and Podman

Sat, 02 Nov 2024 21:45:00 +0000

Spent way too much time trying to get Testcontainers to work with Podman, to find out I just needed to set a flag 🙃.

Transactional outbox pattern meets distributed tracing and OpenTelemetry

Mon, 17 Jun 2024 09:00:00 +0100

Transactional outbox pattern and distributed tracing doesn’t seem like having much in common, right? This post describes how they intersect and a possible approach to get them working together nicely.

Where are my traces? (weird .NET meets OpenTelemetry gotcha)

Mon, 13 May 2024 08:55:00 +0100

Quick post about a weird gotcha I found when using distributed tracing with OpenTelemetry .NET, in a system where not all services have otel setup

Primitive vs strongly typed dictionary keys (feat. frozen collections and BenchmarkDotNet)

Sat, 13 Apr 2024 17:00:00 +0100

Quick post comparing the usage of different types as dictionary keys, including using custom types instead of only primitive types.

A .NET parallel Kafka consumer proof of concept (feat. Akka.NET and the actor model)

Mon, 08 Jan 2024 19:00:00 +0000

For some time now, I’ve been thinking about implementing a parallel Kafka consumer proof of concept in C#. I finally got around to it, and this post describes the process.

Byte array as a dictionary key? Trying out some options

Wed, 06 Dec 2023 13:30:00 +0000

Using arrays as a dictionary key is not really something very common, but I had the need for it, so did some investigation to try and figure out a good way to do it.

Observing .NET microservices with OpenTelemetry - logs, traces and metrics

Tue, 05 Sep 2023 08:10:00 +0100

Observability has been one of the hot topics, with the increasing complexity of knowing what is going on in our applications. Fortunately, .NET has been investing in making things easier with OpenTelemetry.

"Parse, don't validate" and other type safety driven shenanigans (plus a C# wishlist)

Thu, 17 Aug 2023 09:00:00 +0100

Making use of the type system is something I feel should be important when working in a strongly typed language like C#. However, I don’t feel like that’s the case, and I would love for the language to push folks in the direction of creating more robust programs, where the compiler provides more help in proving the correctness of the code.

Enforce conventions (but don't go overboard) with architecture tests

Fri, 28 Jul 2023 08:45:00 +0100

I’ve been trying to flee the over-engineered C# solution structures, with multiple projects, with related code scattered around. Even if an imperfect solution, I’ve turned to NetArchTest to help in guide on following some conventions in a simplified solution structure.

From domain events to infrastructure - thinking out loud about possible approaches I don’t hate

Tue, 16 May 2023 08:20:00 +0100

On the topics of domain-driven design and event-driven architecture, something that’s been on my mind for quite some time, is the process of handling domain events, as well as potentially translating them into integration events.

Checking out EF Core inheritance options

Mon, 08 May 2023 08:25:00 +0100

Recently there was a need to use a hierarchy in a domain model, and there was a question about which of the available approaches to use - table per hierarchy (TPH), table per type (TPT) or table per concrete type (TPC). This very brief post is just a quick look at some benchmarks I created on the subject.

A reminder to consider that your context, isn’t the only context (.NET 8 TimeProvider edition)

Mon, 24 Apr 2023 08:45:00 +0100

This will be a very brief post, just as a reminder that we need to give things a good thought, trying to limit our biases (I’ll focus on software development, but it’s applicable to everything really).

Contract first OpenAPI development (but still use Swagger UI with ASP.NET Core)

Sun, 02 Apr 2023 19:45:00 +0100

In C# and .NET land, we’re pretty heavy on the code first approaches, with the odd exception. Let’s take a look at a possible contract first approach to API development, with OpenAPI, but still taking advantage of existing tooling that we’ve come to rely on, like Swagger UI.

Mapping ASP.NET Core minimal API endpoints with C# source generators

Tue, 31 Jan 2023 17:30:00 +0000

I’m pretty late to the C# source generator party, but hey, better late than never 😅. In this post, let’s take a look at how we can automagically map minimal API endpoints using C# source generators

The “insert specific tech here” developer: yay or nay?

Thu, 19 Jan 2023 17:30:00 +0000

The boxes developers put themselves into is something I’ve given some thought over time. Probably not something folks think about much, but figured I’d write a post about it anyway.

On résumé-driven development, FOMO and dismissing it

Mon, 07 Nov 2022 17:55:00 +0000

I’ve had some of thoughts not exactly résumé-driven development, but more importantly, how engineers, can remain up to date and relevant in the job market, and a recent discussion on LinkedIn reminded me about it.

Beware of records, with expressions and calculated properties

Thu, 01 Sep 2022 18:30:00 +0100

I’ve been using C# records a lot since the feature was introduced. However, when using them, we really need to understand how they work, otherwise we might face unexpected surprises.

[Video] Outbox meets change data capture - hooking into the Write-Ahead Log (feat. .NET, PostgreSQL & Kafka)

Wed, 27 Jul 2022 19:45:00 +0100

Another video on using change data capture (often referred to as CDC), to hook up into the database transaction log, forwarding incoming entries to the outbox table.

[Video] What's the point of async/await in an ASP.NET Core application?

Mon, 30 May 2022 18:00:00 +0100

I’ve been noticing in recent chats that folks have difficulty explaining why do we use async/await, tasks and related, when building ASP.NET Core applications.

[Video] Quick shout-out to DevToys

Tue, 03 May 2022 17:50:00 +0100

Wanted to very briefly share a tool I’ve come across a couple of months ago: DevToys.

[Video] Polymorphic JSON Serialization (feat. .NET & System.Text.Json)

Wed, 13 Apr 2022 19:45:00 +0100

Time for one more video on messing with System.Text.Json, this time to get polymorphic (de)serialization going.

OpenAPI extensions and Swashbuckle

Mon, 21 Feb 2022 17:25:00 +0000

Let’s take a quick look at OpenAPI extensions (which I discovered were a thing last week 😛) and how to add them to our API description using ASP.NET Core and Swashbuckle.

Array or object JSON deserialization (feat. .NET & System.Text.Json)

Mon, 31 Jan 2022 17:25:00 +0000

Ah, the joys of integrating with third-party APIs… We always end up having to hammer something to get things working 🤣. This is a post about one of such situations, resorting to some JSON deserialization trickery (via JsonConverter) to be able to get things working.

[Video] Outbox meets change data capture (feat. .NET, PostgreSQL, Kafka and Debezium)

Mon, 17 Jan 2022 17:30:00 +0000

Quick video with an interesting approach to implement the publisher part of the outbox pattern. Using change data capture (often referred to as CDC), we hook up something to the database transaction log, forwarding incoming entries to the outbox table. In this example, we’ll make use of Debezium, hooked up into a PostgreSQL database, forwarding messages to Kafka.

Getting a complex type as a simple type from the query string in a ASP.NET Core API controller

Mon, 03 Jan 2022 18:00:00 +0000

This is a tale of a good amount of hours of wasted time, so I’m going to document it so I remember it in the future. The idea is simple: when building an API, how can we treat a complex type as a simple type, to avoid things like primitive obsession, implement strongly typed ids and other related patterns? Let’s find out! 🙂

[Video] Checking out NDepend

Mon, 06 Dec 2021 17:15:00 +0000

Let’s take a look at something that’s been around for years, but maybe flew under the radar: NDepend, a static code analysis tool tailored for .NET.

[Video] High-performance and compile-time logging source generation in .NET 6

Sun, 21 Nov 2021 16:30:00 +0000

Quick little video about an interesting new logging related feature coming in .NET 6, compile-time logging source generation, as well as related high-performance logging features, which were already present but probably not very well known.

[Video] Exploring distributed tracing with ASP NET Core 6

Tue, 26 Oct 2021 18:45:00 +0100

Distributed tracing isn’t a new subject by any means, but there are some more recent developments, namely in terms of standards like W3C Trace Context and OpenTelemetry, that are worth a look.

[Video] Are ASP.NET Core Minimal APIs just for demos?

Tue, 17 Aug 2021 17:45:00 +0100

The upcoming release of ASP.NET Core 6 brings a pretty interesting feature set referred to as “Minimal APIs”. While they seem pretty interesting to me and many others, some folks are not fans and can be quite vocal about it, so I thought about taking quick look, put things in perspective, as well as compare with other tech stacks.

Next level console apps with Spectre.Console

Tue, 27 Jul 2021 19:15:00 +0100

Don’t know about you, but when I build console applications, pretty is not a word I use to describe them. Let’s see how Spectre.Console can help us with that!

Mistaking software for a finished product

Mon, 10 May 2021 18:30:00 +0100

As much as it would be simpler, software isn’t something we can ship and forget about, or even just keep adding features without revisiting architecture and design.

Virtual as a code smell*

Wed, 07 Apr 2021 18:45:00 +0100

Lately I noticed I’m essentially treating virtual methods as a code smell, so thought it could result in an interesting blog post.

Setting up demos in Azure - Part 2: GitHub Actions

Sun, 14 Mar 2021 16:00:00 +0100

Building on the work from the previous post, in this one we make use of GitHub Actions to setup workflows for easy setup and tear down of a demo environment in Azure.

Setting up demos in Azure - Part 1: ARM templates

Sun, 07 Mar 2021 10:30:00 +0100

As I’m preparing some demos using Azure services, wanted to have things in place so I can easily setup the whole environment. In this first part, we look at using Azure Resource Manager (ARM) templates to get all those services up and running.

Streamlining package versioning with MinVer

Sun, 24 Jan 2021 16:00:00 +0100

In the past two posts on the path to publish a NuGet package, we started by setting up the build with NUKE and running it with GitHub Actions. Before we get to the actual publishing part, there’s one more thing we need, which is to handle versioning.

Getting started with GitHub Actions

Tue, 22 Dec 2020 18:30:00 +0100

In a previous post, we started to prepare the build pipeline for a new library, using NUKE. In this post, we’re going to continue that work, setting up continuous integration, running the build with GitHub Actions when changes arrive.

Going all-in with nullable reference types

Sat, 28 Nov 2020 11:00:00 +0100

I know I’m late to the party, but just recently had the opportunity to start using nullable reference types more seriously, so thought of gathering the first steps taken to go all-in with it.

.NET Conf 2020 and .NET 5 links

Sun, 15 Nov 2020 12:30:00 +0100

.NET Conf 2020 is done and .NET 5 is finally here! Information about this release is spread across a bunch of blogs, videos and whatnot, so I thought of grabbing a bunch of links and put them in a post for quick reference.

Setting up a build with NUKE

Sat, 24 Oct 2020 19:00:00 +0100

Let’s take a look at NUKE, a cross-platform build automation system with C# DSL. We’ll use it to define the build for a new library that will eventually make its way to NuGet.

Shaking things up a bit - ASPF02O Outro

Mon, 21 Sep 2020 11:00:00 +0100

Almost two years have passed since I started the “ASP.NET Core: From 0 to Overkill” series. It’s time to shake things up a bit 🙂.

Some comments, tips and rants about my path to Kubernetes certification

Mon, 07 Sep 2020 18:30:00 +0100

Sharing my experience about my path to learn about Kubernetes and prepare for the Certified Kubernetes Application Developer (CKAD) exam.

Event-driven integration #6 - Publishing events (feat. Apache Kafka) [ASPF02O|E045]

Tue, 18 Aug 2020 11:00:00 +0100

In this episode, we implement event publishing to Apache Kafka from the auth service, making use of Confluent’s .NET client package.

Microservices and correctly built distributed systems

Wed, 15 Jul 2020 18:30:00 +0100

Microservices are all the rage for some time now, but are we using the right foundations to create them? In this post, we’ll look into a common design issue in distributed systems.

Event-driven integration #5 - Quick intro to Apache Kafka [ASPF02O|E044]

Tue, 09 Jun 2020 18:30:00 +0100

In this episode, we briefly introduce Apache Kafka, as we’ll use it to implement our event bus. We’ll focus on our specific use case, as Kafka can be used in a variety of scenarios. We’ll keep it in a developer’s perspective, not going much into more infrastructural subjects.

Event-driven integration #4 - Outbox publisher (feat. IHostedService & Channels) [ASPF02O|E043]

Thu, 07 May 2020 10:30:00 +0100

In this episode, we’ll implement the outbox publisher, or better yet, two versions of it, one better suited for lower latency and another for reliability. As we continue our event-driven path, this will be a good opportunity to introduce a couple of interesting .NET Core features: IHostedService (and BackgroundService) and System.Threading.Channels.

Event-driven integration #3 - Storing events in the outbox table [ASPF02O|E042]

Tue, 28 Apr 2020 17:30:00 +0100

On the footsteps of the last episode, in this one we store the inferred events in the outbox table, doing so transactionally, so we have guarantees that any change will eventually result in a published event.

Event-driven integration #2 - Inferring events from EF Core changes [ASPF02O|E041]

Mon, 20 Apr 2020 18:00:00 +0100

In this first step implementing event-driven integration between services, we’ll hook-up into EF Core’s infrastructure, namely when saving changes, to infer if any event should be raised based on the information provided by the change tracker.

Event-driven integration #1 - Intro to the transactional outbox pattern [ASPF02O|E040]

Mon, 13 Apr 2020 17:30:00 +0100

As we start implementing event-driven integration, the first thing we need to do is publish the events. Although it might seem straightforward, there are some important things to consider in order to make it work reliably. In this episode, we discuss the challenges and introduce the transactional outbox pattern to help us facing these challenges.

Event-driven integration - Overview [ASPF02O|E039]

Sun, 05 Apr 2020 11:30:00 +0100

In this episode, we take a look at the integration problem we have between services right now, go through some options to avoid or fix it, then have a quick overview of the solution we’ll be implementing in the coming episodes.

More explicit domain error handling and fewer exceptions with Either and Error types [ASPF02O|E038]

Mon, 02 Mar 2020 18:30:00 +0000

Following up on the last episode about the Optional type, we continue taking inspiration from functional languages and introduce Either and Error types, as a way to make the possible business logic outcomes more explicit and minimize using exceptions in non-exceptional situations.

Better use of types - avoiding nulls with an Optional type [ASPF02O|E037]

Mon, 17 Feb 2020 18:00:00 +0000

In this post, we’ll make use of a concept most commonly associated with functional programming, the Optional type (aka Option or Maybe), in order to make our code safer and more explicit when expressing a lack of value, instead of leaning on the null reference, something that I’m sure has burned us many times in the past.

E036 - Making things more object oriented with rich domain entities - ASPF02O

Thu, 06 Feb 2020 19:30:00 +0000

In this episode, we’ll make things more object oriented, by moving some logic that’s present in the request handlers, which in fact should be present in the domain entities, that currently are just bags of data with public getters and setters.

A look at Building the Future 2020

Tue, 04 Feb 2020 18:45:00 +0000

This past week I had the opportunity to attend Building the Future 2020, an event focused on digital transformation, so I thought about sharing some of the main topics that stuck with me.

E035 - Experimenting with (yet) another approach to data access organization - ASPF02O

Mon, 20 Jan 2020 19:00:00 +0000

In this episode, we’ll take a look at (yet) another approach to organizing data access code, very likely overkill.

E034 - Segregating use cases with MediatR - ASPF02O

Fri, 10 Jan 2020 18:25:00 +0000

In this episode, we’ll take a look at segregating our application use cases in dedicated classes instead of shoving everything into the same service class.

E033 - Redesigning the API: Improving the internal architecture - ASPF02O

Fri, 20 Dec 2019 18:25:00 +0000

In this episode, we’ll take a look at redesigning an API that has been developed in a traditional layered way, moving to a more interesting onion/hexagonal/ports and adapters architecture (which is apparently very fashionable right now in .NET land).

Use POCOs to group data and logic - there's more to life than services and DTOs

Tue, 10 Dec 2019 20:00:00 +0000

In C# land, the abuse of services and DTOs is prevalent. How about grouping data and behavior using POCOs? You know, ob)ect oriented stuff 🙂.

"Equals" and "==" are not... equal

Sun, 01 Dec 2019 18:00:00 +0000

“Equals” vs “==” is an old topic, but as it’s often times forgotten, there’s probably no harm in talking about it again.

Episode 032 - Upgrading to ASP.NET Core 3.0 - ASP.NET Core: From 0 to overkill

Thu, 21 Nov 2019 18:30:00 +0100

In this episode, we’ll go through the main changes required to upgrade our currently ASP.NET Core 2.2 applications to ASP.NET Core 3.0.

A year remote

Sun, 03 Nov 2019 16:45:00 +0000

It has recently been a year since I started working remotely, so I thought it could be interesting to share my experience, along with some particularities of my remote setting.

Episode 031 - Some simple unit tests with xUnit - ASP.NET Core: From 0 to overkill

Fri, 25 Oct 2019 18:00:00 +0100

In this episode, we’ll take a little break from the explorations we’ve been doing in the latest episodes, getting back to fundamentals and writing some really simple unit tests with xUnit.

Episode 030 - Analyzing performance with BenchmarkDotNet - ASP.NET Core: From 0 to overkill

Tue, 08 Oct 2019 17:45:00 +0100

In this episode, we’ll take a look at BenchmarkDotNet, to explore the performance characteristics of our code and help us make better decisions when trying to optimize it.

Episode 029 - Simplifying the BFF with ProxyKit - ASP.NET Core: From 0 to overkill

Wed, 11 Sep 2019 18:30:00 +0100

In this episode, we’ll revise our current backend for frontend implementation, introducing ProxyKit to simplify request routing to backing APIs, foregoing the need to implement everything manually.

Episode 028 - Multiple service instances tweaks - ASP.NET Core: From 0 to overkill

Sat, 31 Aug 2019 12:30:00 +0100

In this episode, we’ll take a look at some things we need to keep in mind when we want to run multiple instances of an ASP.NET Core application, namely data protection configuration and how it impacts our application even without us using it directly.

Episode 027 - Up and running with Docker Compose - ASP.NET Core: From 0 to overkill

Mon, 12 Aug 2019 17:30:00 +0100

In this episode, we’ll take the Docker containers we prepared previously and use Docker Compose to get the complete PlayBall application running.

Episode 026 - Getting started with Docker - ASP.NET Core: From 0 to overkill

Mon, 29 Jul 2019 17:30:00 +0100

In this episode, we’ll be creating Docker containers for our applications, with the goal of making it easier to get them all running as a whole.

Episode 025 - Integrating IdentityServer4 - Part 5 - Frontend - ASP.NET Core: From 0 to overkill

Sat, 13 Jul 2019 15:30:00 +0100

In this episode, we take a look at our frontend single page application, and the changes made to handle user authentication. We also take a look at a way to handle the CSRF token in the requests made to the BFF.

Episode 024 - Integrating IdentityServer4 - Part 4 - Back for Front - ASP.NET Core: From 0 to overkill

Sat, 22 Jun 2019 23:00:00 +0100

In this episode, we look at the backend for frontend, and the changes required for it to handle the users authentication, redirection to the identity provider (the IdentityServer4 powered auth service), the inclusion of an access token when making API calls, the refresh of said token and handling CSRF tokens.

Episode 023 - Integrating IdentityServer4 - Part 3 - API - ASP.NET Core: From 0 to overkill

Sun, 16 Jun 2019 20:00:00 +0100

In this episode, we look at the group management service, and the changes required for it to enforce the requests authentication using an access token (JWT).

Episode 022 - Integrating IdentityServer4 - Part 2 - Auth Service - ASP.NET Core: From 0 to overkill

Thu, 13 Jun 2019 18:00:00 +0100

In this episode, we start looking at the code needed to integrate IdentityServer4 in our application, namely with the authentication service we developed previously.

Episode 021 - Integrating IdentityServer4 - Part 1 - Overview - ASP.NET Core: From 0 to overkill

Wed, 29 May 2019 19:20:00 +0100

In this episode, we start with an overview of the current application’s architecture and how we’ll start integrating IdentityServer4 into it.

The Uri composition mystery

Wed, 22 May 2019 21:30:00 +0100

A quick tale of an idiot wasting hours by not checking the docs earlier.

Episode 020 - The backend for frontend and the HttpClient - ASP.NET Core: From 0 to overkill

Sun, 05 May 2019 09:30:00 +0100

In this episode, we’ll start building our backend for frontend, which will bridge the interaction between the Vue.js frontend application and the backend APIs we’ll develop. For now this will be mostly an excuse for playing with the HttpClient in ASP.NET Core, as we’ll improve the BFF in the future, with some proxying capabilities for requests that don’t need additional logic.

Episode 019 - Roles, claims and policies - ASP.NET Core: From 0 to overkill

Mon, 29 Apr 2019 18:30:00 +0100

In this episode, we get back to the authorization topic, playing a bit with roles, claims and policies in ASP.NET Core, learning how we can use these to restrict access to certain areas of our application.

Episode 018 - Internationalization - ASP.NET Core: From 0 to overkill

Wed, 24 Apr 2019 21:30:00 +0100

In this episode, we’ll use ASP.NET Core internationalization support to make our authentication service available in multiple languages.

Episode 017 - More Identity, more Razor Pages - ASP.NET Core: From 0 to overkill

Sun, 31 Mar 2019 18:00:00 +0100

In this episode, we continue exploring ASP.NET Core Identity and Razor Pages as we continue development of our authentication service.

Episode 016 - Authentication with Identity and Razor Pages - ASP.NET Core: From 0 to overkill

Sun, 24 Feb 2019 16:20:00 +0000

In this episode, we start building the authentication service, using ASP.NET Core Identity and Razor Pages. It will be a standalone application centralizing all the required user authentication logic.

Episode 015 - Calling the Web API from the frontend - ASP.NET Core: From 0 to overkill

Tue, 12 Feb 2019 17:30:00 +0000

Wrapping up this first look at the frontend application built with Vue.js, in this episode we make it work with the group management Web API we developed so far.

Episode 014 - Centralizing frontend state with Vuex - ASP.NET Core: From 0 to overkill

Thu, 07 Feb 2019 19:30:00 +0000

In this episode, we continue playing around in the frontend, by centralizing all state using Vuex, making use of the patterns that are probably more popular lately due to their use with React and Redux.

Episode 013 - Starting the frontend with Vue.js - ASP.NET Core: From 0 to overkill

Sat, 02 Feb 2019 19:20:00 +0000

In this episode, we start the frontend development with Vue.js. One can say this isn’t ASP.NET Core, but we do need a frontend and single page applications are all the rage these days, so we’re going with the flow 😛

Episode 012 - Move to a Web API - ASP.NET Core: From 0 to overkill

Sat, 26 Jan 2019 17:30:00 +0000

In this episode, we start transforming the current application into a Web API, so it can be used in the single page application we’ll be developing.

Episode 011 - Data access with Entity Framework Core - ASP.NET Core: From 0 to overkill

Wed, 16 Jan 2019 20:45:00 +0000

In this episode, we replace our current groups “persistence” with an actual database, accessing it with Entity Framework Core.

Episode 010 - Async all the things - ASP.NET Core: From 0 to overkill

Mon, 17 Dec 2018 20:00:00 +0000

In this episode, we take a look at using async await in ASP.NET Core, why it’s important, the happy path and some sad paths, along with some interesting bits.

Episode 009 - MVC filters - ASP.NET Core: From 0 to overkill

Mon, 10 Dec 2018 17:25:00 +0000

Following up on the previous episode on ASP.NET Core middlewares, in this episode we take a look at MVC’s filters, an MVC specific way to add behaviors to our request handling pipeline, and how we can use them to implement cross-cutting concerns in our web applications.

Episode 008 - Middlewares - ASP.NET Core: From 0 to overkill

Wed, 05 Dec 2018 18:30:00 +0000

In this episode we take a look at ASP.NET Core’s middlewares, how to create them and use them in the request handling pipeline.

Episode 007 - Logging - ASP.NET Core: From 0 to overkill

Wed, 21 Nov 2018 19:30:00 +0000

In this episode we take a look at logging in ASP.NET Core, the builtin support and providers, as well as using third party implementations, namely NLog.

Episode 006 - Configuration - ASP.NET Core: From 0 to overkill

Fri, 16 Nov 2018 19:00:00 +0000

In this episode we take a look at configuration in ASP.NET Core, the possible sources, how to read from them, the options pattern, wrapping up with development time secrets.

Episode 005 - Dependency Injection - ASP.NET Core: From 0 to overkill

Sun, 04 Nov 2018 11:30:00 +0000

In this episode we go a little bit deeper into dependency injection, extracting our logic from the controller and into a service.

Episode 004 - The Program and Startup classes - ASP.NET Core: From 0 to overkill

Sat, 27 Oct 2018 21:45:00 +0100

In this episode we take a step back to look at some important infrastructure parts of an ASP.NET Core application - the Program and the Startup classes.

Episode 003 - First steps with MVC - ASP.NET Core: From 0 to overkill

Sat, 13 Oct 2018 16:30:00 +0100

In this episode we pick up on the component started previously for group management, to start adding some ASP.NET Core MVC goodness to it.

Episode 002 - Project structure plus first application - ASP.NET Core: From 0 to overkill

Sun, 07 Oct 2018 10:00:00 +0100

In this post we finally see some code, although not much 😛 We start by checking out the project structure that’ll be used in .NET repositories and then find our way through the command line to create the solution and C# project for the group management component.

Episode 001 - The Reference Project - ASP.NET Core: From 0 to overkill

Sat, 06 Oct 2018 18:20:00 +0100

In this post, we’ll take a look at the objective of the reference, before starting to code like there’s no tomorrow without anyone understanding the context.

ASP.NET Core: From 0 to overkill - Intro

Tue, 02 Oct 2018 22:40:00 +0100

This post serves as an introduction to a new series of videos (and I’ll try to accompany them with posts) on creating a complex application using on ASP.NET Core.

Finally found a cross-platform Excel parsing library

Sat, 15 Sep 2018 13:00:00 +0100

I have surely been living under a rock, not knowing about the ExcelDataReader library, but now I do!

First look at Kotlin - my first pains

Wed, 12 Sep 2018 19:45:00 +0100

A quick walk-through of a couple of problems I ran into when first trying to build a web api with Kotlin

[Redirect Magazine] #27 - ASP.NET Core and Serilog, techie to tech lead, microservices and messaging

Sun, 09 Sep 2018 11:00:00 +0100

Another week, another bunch of links!

I think I’ll reduce the cadence from now on though, to do a little more of my own posts/videos and not have the blog almost exclusively filled with links 🙂.

Articles

“Writing logs to Elasticsearch with Fluentd using Serilog in ASP.NET Core”

The title says it all 🙂 Nice and simple article on the subject.

“Techie to tech lead: My five biggest mistakes”

Interesting article on some mistakes one might make when transitioning from a technical role to a leadership one.

[Redirect Magazine] #26 - Web performance, constructor over-injection and the Elastic stack

Sun, 02 Sep 2018 10:20:00 +0100

Have at it!

Articles

“I Wanna Go Fast: Why Searching Through 500M Pwned Passwords Is So Quick”

Really cool post on web performance by Troy Hunt on hist Have I Been Pwned project.

“On Constructor Over-injection”

Can’t add much on this article, the title is self explanatory and the article is short and to the point.

Videos

“Data magic with the Elastic stack! - Aleksander Stensby”

Cool talk on some interesting capabilities of Elastic Search and Kibana.

[Redirect Magazine] #25 - Event sourcing problems, Bing on .NET Core 2.1 and testing distributed systems

Sun, 26 Aug 2018 12:20:00 +0100

And we’re in for another round!

Articles

“What they don’t tell you about event sourcing”

Nice read on some problems that might arise when using CQRS and event sourcing.

“Bing.com runs on .NET Core 2.1!”

Interesting to know how Bing is benefiting from .NET Core performance improvements. Even if you (and I) don’t like/use Bing, it’s still a massive project and a great way to see how .NET Core behaves at such scale.

[TIL] int vs short and the (unexpected) performance impact

Sat, 25 Aug 2018 12:30:00 +0100

Quick little post on a probably unexpected performance difference when using an int instead of a short in C#

[Redirect Magazine] #24 - Service boundaries, orchestrating containers, event sourcing and CQRS, plus some ASP.NET Core less known features

Sun, 19 Aug 2018 18:30:00 +0100

This week, no reading, just watching 🙂

(Now that I’m looking at it closely, all the videos are from NDC Oslo 2018)

Videos

“Finding your service boundaries - a practical guide - Adam Ralph”

Great talk on defining the service boundaries, one of the topics I find most challenging when creating a new system, but also very interesting.

[Video] Creating a CI/CD pipeline for a .NET library

Sun, 19 Aug 2018 09:50:00 +0100

Video series on setting up a complete CI/CD pipeline for a .NET library, from building and testing in different platforms, visualizing code coverage and publishing the binaries to NuGet.'

[Redirect Magazine] #23 - distributed systems, testing, more distributed systems and actors on distributed systems

Sun, 12 Aug 2018 19:45:00 +0100

A couple of reads and a couple of watches.

Articles

“Life Beyond Distributed Transactions: An Apostate’s Implementation - A Primer”

Nice series of articles (not yet finished) on implementing transactional logic in a distributed system without resorting to the traditional SQL distributed transactions.

“Software Testing Anti-patterns”

Excellent thorough article on testing anti-patterns, technology stack agnostic, with valuable information to make sure we get the most out of our tests.

[Redirect Magazine] #22 - Imaginary problems, .NET pipelines, patterns misuse, architecture resources and CI/CD

Sun, 05 Aug 2018 17:45:00 +0100

Another week gone by (and this wasn’t a cold one over here), another bunch of links.

Articles

“Imaginary problems, the root of bad software”

Very nice post on the problems, the real and the imaginary ones, we face on our jobs. After reading I’m pretty confident you can relate.

“Pipelines - a guided tour of the new IO API in .NET, part 3”

Another really nice article on .NET’s pipelines from Marc Gravell. Really thorough and awesome to get to know these lower level network and IO related topics, really different from the usual application code many of us write daily.

Creating a CI/CD pipeline for a .NET library: Part 3 - Building on AppVeyor and Travis CI

Mon, 30 Jul 2018 20:00:02 +0100

In this third post we get our build running in the cloud, compiling and testing in Windows, Linux and MacOS.

Creating a CI/CD pipeline for a .NET library: Part 4 - Code coverage on Coveralls, badges and wrap up

Mon, 30 Jul 2018 20:00:02 +0100

In this fourth post, we’ll add the final touches to the pipeline, publishing the code coverage report and adding some badges to GitHub.

Creating a CI/CD pipeline for a .NET library: Part 2 - Defining the build with Cake and publishing to NuGet

Mon, 30 Jul 2018 20:00:01 +0100

In this second post we get started with the CI/CD pipeline, defining the build steps in C# using Cake.

Creating a CI/CD pipeline for a .NET library: Part 1 - Intro

Mon, 30 Jul 2018 20:00:00 +0100

Setting up a complete CI/CD pipeline for a .NET library, from building and testing in different platforms, visualizing code coverage and publishing the binaries to NuGet.

[Redirect Magazine] #21 - Web architecture fundamentals, stability patterns and antipatterns plus a quick look at Kotlin

Sun, 29 Jul 2018 09:50:00 +0100

Not a big list this week, as I’ve been working on my own posts most of the time. Hopefully I’m able to get them published by tomorrow.

Articles

“Web Architecture 101”

Nice article on a typical system’s main architecture components. Maybe a given for more senior developers, but I find it an interesting quick intro for less experienced ones.

Videos

“GOTO 2016 • Stability Patterns & Antipatterns • Michael T. Nygard”

Very interesting talk on systems stability and availability, some examples of weird things that happened from the speaker’s experience, some patterns and anti-patterns.

[Redirect Magazine] #20 - Debugging HTTP requests in Docker, homographs, learning new things and evolutionary architectures

Sun, 22 Jul 2018 10:50:00 +0100

Been reading through my saved posts on dev.to, so the source for today is mostly that.

Articles

“Intercept HTTP traffic exiting a docker container”

Nice example on how to intercept HTTP and HTTPS requests coming from a Docker container for debugging.

“Homographs, Attack!”

Had already seen some quick articles on these kinds of attacks where the URL for a page is not what it looks like, but this is a really good post explaining things in more depth.

[Redirect Magazine] #19 - Microservices gone sour, OOP done wrong, more on .NET's new Pipelines and HTTPS all the things

Sun, 15 Jul 2018 19:30:00 +0100

Some more reading material.

Articles

“Goodbye Microservices: From 100s of problem children to 1 superstar”

Interesting read on an implementation of a microservice architecture that went wrong, and a come back to a monolithic approach that worked. Maybe the microservices approach was not the best one, maybe it wasn’t just well implemented or adequate for the problem at hand, but it’s an important lesson that sometimes it works, sometimes it doesn’t an a monolith is just fine.

[Redirect Magazine] #18 - Span, Memory and Pipelines on .NET Core 2.1

Sun, 08 Jul 2018 19:15:00 +0100

This past week wasn’t great productivity wise, but I could still get some reading on two pretty interesting .NET related topics.

Articles

“Introducing .NET Core 2.1 Flagship Types: Span T and Memory T”

Nice overview on some of the biggest additions on .NET Core 2.1, Span and Memory. Some lower level stuff that could be really important for performance improvements.

“Pipelines - a guided tour of the new IO API in .NET, part 1”

Series of posts on a new set of APIs introduced in .NET Core 2.1 to work with IO - Pipelines.

Cyaz!

[Redirect Magazine] #17 - Using containers for build environments, configuration in .NET Core, HTTPS all the things, containerized distributed data stores and Shopify's architecture

Sun, 01 Jul 2018 18:30:00 +0100

Another pair of each to wrap up the weekend.

Articles

“Containers - What Are They Good For? Crafting our Build Environments”

Quick post on using Docker containers to create a build environment for .NET projects.

“Deep Dive into Microsoft Configuration”

Excellent thorough walkthrough of the configuration system used in .NET Core applications.

“HTTPS Is Easy!”

Don’t be one of those that says “my site doesn’t need HTTPS because of reasons”! HTTPS all the things!

[Redirect Magazine] #16 - Sharing sources through NuGet, modern .NET overview, some more microservices and a tour through programming history

Sun, 24 Jun 2018 10:30:00 +0100

Another week, another round, today more videos than articles.

Articles

“Source Code Only NuGet Packages”

Knowing I could do this would have been useful in the past… at least I know now :)

Videos

“Why I’m Not Leaving .NET - Mark Rendle”

A tour on some features that make it working with .NET right now one of the best times it has ever been.

## ["Microservices: How To Build Systems That Survive"](https://youtu.be/rNQR1HqfEl0) Some ideas on using microservices (or small components as it's referred to by the speaker) to build systems that aren't completely rebuilt every now and then, but rather replacing components as needed (eventually leading to a completely rewritten system code anyway).

## ["GOTO 2018 • Old Is the New New • Kevlin Henney"](https://youtu.be/AbgsfeGvg3E) Kevlin Henney with another tour on our "new" software development ideas and paradigms, and where they came from.

Cyaz!

[Redirect Magazine] #15 - Performance with strings in .NET, cryptography, Node.js issues, microservices and clean architecture

Sun, 17 Jun 2018 17:00:00 +0100

Today, besides the usual articles and videos, I added a podcast into the mix.

Articles

“Strings Are Evil”

Very cool article on massively improving the performance of a document parsing application, mainly in regard to memory allocations, and the issues working with strings carelessly in .NET can cause.

“Timing vulnerabilities with CBC-mode symmetric decryption using padding”

Using cryptography correctly ain’t a walk in a park. I don’t usually read much about this topic, but it’s important to at least be alert to some things, so we’re able to talk to someone who really understands the topic and we can be confident our code isn’t vulnerability ridden.

[Redirect Magazine] #14 - Micro Frontends, Polly extensions for HttpClient, WebSockets and Nginx

Sun, 10 Jun 2018 10:00:00 +0100

Have at it!

Articles

“Micro Frontends”

On the same page as a video I shared on Redirect Magazine #12, this article talks about taking the microservices architecture into the frontend, so we don’t end up with a fancy microservice backend coupled with a monolithic frontend, kind of defeating the purpose of the architectural decision in the first place.

“HttpClientFactory in ASP.NET Core 2.1 (Part 4) - Integrating with Polly for transient fault handling”

I’ve made some posts on using Polly to improve .NET applications resilience in the past, so it’s nice that it now as some helpers to be integrated with HttpClient in ASP.NET Core.

[Redirect Magazine] #13 - .NET Core 2.1 released, Twelve-Factor App, Reactive Manifesto, readable code, Rx on the cloud and extra JS stuff

Sat, 02 Jun 2018 10:15:00 +0100

Here ye go!

Articles

“Announcing .NET Core 2.1”

.NET Core 2.1 is now final and here’s what it brings.

“The Twelve-Factor App”

Nice set of guidelines on developing applications (focusing on SaaS). This is really far from new, but I only recently got around to reading the whole thing. By now most of what’s described sounds a bit obvious, but it’s good it’s written somewhere.

“The Reactive Manifesto”

In the spirit of the previous article, another set of recommendations for application development, making them “reactive”. This has more of a focus on distributed systems and how the various components should interact.

[Redirect Magazine] #12 - More JS inner workings, serverless, ASP.NET Core 2.1 and microservice websites

Sun, 27 May 2018 15:00:00 +0100

Aaaaand it’s another round incoming!

Articles

“How JavaScript works: an overview of the engine, the runtime, and the call stack”

A two part series of posts on how JS works, somewhat in line with some videos I shared in the past.

“Serverless Architectures”

By now most of us have some idea of what serverless is, but this is a more comprehensive article that covers a lot of topics on this subject.

[Redirect Magazine] #11 - Async stuff, cleaning up DI, using Git merge, Spotify engineering culture and new shiny things in EF Core

Sun, 20 May 2018 18:00:00 +0100

Had to get into some last minute reading to have enough links to share, but here they are! :)

Articles

“Task, Async Await, ValueTask, IValueTaskSource and how to keep your sanity in modern .NET world”

Starting with some history and getting into the latest additions, a nice little intro into the asynchronous features in .NET.

“Tame Your Giant, Beastly Dependency Injection Registration Class and Ride It Into Glorious Victory “

Some recommendations on taking care of the dependency injection configuration code.

Dotnetifying gRPC: Sane Edition

Sat, 19 May 2018 12:00:00 +0100

Going about the usual way of implementing a gRPC service in .NET, creating some helpers to make it a more ASP.NET Core like experience.

[Redirect Magazine] #10 - Events past week, .NET Core future, project versioning, Visual Studio Live Share, Angular 6 and the new SignalR

Sun, 13 May 2018 08:30:00 +0100

This past week had Microsoft Build and Google I/O, lots of stuff to check out (and so little time).

Articles

".NET Core 3 and Support for Windows Desktop Applications"

Some insights on whats coming in .NET Core. Many things are Windows only, but at least those that still need to target specifically Windows will be able to take advantage of .NET Core goodies when building desktop applications (WPF and Windows Forms).

[Redirect Magazine] #9 - GraphQL vs REST, multi-targeting .NET libraries, analyzers and designing APIs

Sun, 06 May 2018 12:00:00 +0100

Slower week, a few more links anyways!

Articles

“REST vs GraphQL APIs, the Good, the Bad, the Ugly “

Interesting comparison between REST and GraphQL APIs.

“Targeting builds for multiple frameworks and machines”

Nice read on a use case for multi targeting a .NET project across frameworks and operating systems, for a complete multi platform experience.

“Avoiding struct and readonly reference performance pitfalls with ErrorProne.NET”

Introduction to a set of analyzers to help with some of the latest C# performance oriented features regarding structs.

[Redirect Magazine] #8 - HttpClient, the actor model, saga pattern, ASP.NET Core issues and some more perf stuff

Sun, 29 Apr 2018 11:45:00 +0100

Here comes some more link goodness!

Articles

“HttpClientFactory for typed HttpClient instances in ASP.NET Core 2.1”

Using the new HttpClientFactory with ASP.NET Core 2.1.

“HttpClientFactory in ASP.NET Core 2.1 (Part 1)”

Some more info on HttpClientFactory with ASP.NET Core 2.1. This is a much more detail set of articles then the one by Scott Hanselman. The link is for part one but you can then follow through the others, 3 in total at this moment.

Using .NET's HttpClient without following redirects

Sat, 28 Apr 2018 12:00:00 +0100

It’s likely not a common scenario, but here’s how one can use .NET’s HttpClient without following redirects.

[Redirect Magazine] #7 - Using Firefox, .NET Core 2.1 performance improvements, learning new skills and new C# features

Sun, 22 Apr 2018 10:15:00 +0100

“Another day, another carrot”… I mean, another redirect magazine!

Articles

“It’s time to give Firefox a fresh chance”

While not directly code related, I think this is an important topic. As developers we, better than anyone else, should know that having an application only work well on one browser is terrible. We haven’t even got rid of those horrible sites that require us to fire up Internet Explorer (and Java applets for that matter) and are slipping into a similar scenario with Chrome. Granted Chrome is a great browser, but that shouldn’t make it an excuse to be lazy and disregard everything else. As long as it’s not a steaming pile of crap and implements the standards, it should work.

Using cancellation tokens on ASP.NET Core MVC actions

Sat, 21 Apr 2018 19:00:00 +0100

Cancellation tokens are really useful when working with async stuff, and this is the simplest way of getting some nice free benefits in ASP.NET applications using them.

Dotnetifying gRPC

Sun, 15 Apr 2018 20:40:00 +0100

Very likely over-engineered PoC on making development of gRPC service development more dotnetish.

[Redirect Magazine] #6 - Code reviews, side projects, functions as dependencies and performance profiling

Sun, 15 Apr 2018 10:00:00 +0100

This week has been a little slower, but I still have some nice stuff to share while I’m finishing up a post on a little PoC I did with gRPC (code here).

Articles

“Why junior devs should review seniors’ commits”

Some good reasons for all developers to be involved in the code review process, not just the senior ones.

“What does a good side project look like?”

While I disagree that one must have side projects, if there’s interest in having one, these article talks about some of the possible benefits of it.

[Redirect Magazine] #5 - Repository pattern diverging opinion, .NET and Go concurrency, JS Event Loop and Zones

Sun, 08 Apr 2018 11:00:00 +0100

Some more reading/watching material. A bit more Go this week, as I would love to use it to build something but haven’t got around to do it - my attention span in pet projects is terrible, I start one thing then get another idea and forget the previous :)

Articles

“Is the repository pattern useful with Entity Framework Core?”

An alternative point of view on the much used repository pattern.

[Redirect Magazine] #4 - CLI tools, coding ASP.NET Core on Linux, actors and some more perf stuff

Sun, 01 Apr 2018 09:00:00 +0100

Here comes another round of interesting reads/watches.

Articles

“Command line “tab” completion for .NET Core CLI in PowerShell or bash”

Something I had no clue that existed:.NET command line autocomplete and static file server.

“Diving deep into JavaScript array – evolution & performance “

Some insights on the array performance in JavaScript.

“Dataflow (Task Parallel Library)”

I had no clue there was an actor model like API tied into the TPL. Always nice to find out (even if years late).

[Redirect Magazine] #3 - DDD with EF Core, ASP.NET Core, JS and .NET perf and some logging bits

Sun, 25 Mar 2018 11:00:00 +0100

Articles

“Creating Domain-Driven Design entity classes with Entity Framework Core”

Nice approach to implement domain driven design entity classes using EF Core. Some prior ideas on DDD might help in better understanding the article, but at very least it might pique your interest in learning more about it.

“Exploring the Microsoft.AspNetCore.App shared framework in ASP.NET Core 2.1 (preview 1)”

Overview of the way an ASP.NET Core application dependencies are handled, and the changes introduced from 2.0 to 2.1.

[Redirect Magazine] #2 - Stack Overflow developer survey, general tips, code reviews and some other stuff

Sun, 18 Mar 2018 10:00:00 +0000

Here comes another round of (interesting?) links!

Articles

“Stack Overflow Developer Survey Results 2018”

Always good to check out the state of our world.

“Service Fabric is going open source”

I’m sharing this not really for the content itself, which is not very thorough on the subject, but because we keep seeing this fundamental shift in Microsoft’s strategy, making more and more stuff open source, and that’s very cool!

My couple of cents on remote work

Thu, 15 Mar 2018 21:45:00 +0000

Well, this is a very written about topic isn’t it? I wasn’t going to write about it, given the myriad of articles that already exist on the subject, but whilst watching the news today some extra ideas on it emerged and I thought, what the hell, I’ll add one of my one to the never ending list.

I’m not going for a pros and cons approach, those were already written plenty of times. I just wanted to add some ideas that I seldom see associated to the topic.

[Redirect Magazine] #1 - Sharing some links

Sun, 11 Mar 2018 11:30:00 +0000

Haven’t shared anything in a while, but that doesn’t mean I’m not up to something (I even recorded a video based on the Docker + Angular + ASP.NET Core post, but the sound turned out crappy and I scratched that).

To try to avoid these times I don’t share something I created, I thought of starting a (hopefully) weekly “magazine” linking to some stuff I’ve been reading/watching.

Articles

“JPEG, GIF, PNG OR SVG - Which should You use?”

Some guidance on image formats to use on your web app.

Quick intro to Docker and Docker Compose: Angular, ASP.NET Core and Postgres app

Wed, 31 Jan 2018 19:30:00 +0000

Intro

I wanted to play a little with Docker Compose so I created a little PoC that had the usual components of a web application: a frontend, a backend and a supporting database.

Sample code to follow along here.

Sample overview

As I was just looking for the simplest thing just to make all the bits work together, I whipped out a pretty stupid scenario. The application basically lists some counters and increments each one as it’s selected.

[Video] Moving the blog to Jekyll and hosting on Netlify

Mon, 29 Jan 2018 22:00:00 +0000

Just added a new video, talking about the blog’s move from WordPress (and all that infrastructure I talked about in these series of posts) to a static site, generated using Jekyll and hosted using Netlify.

A side note that I forgot to mention in the video: when using Jekyll, we need to set the environment variable JEKYLL_ENV to production, or stuff like Google Analytics and Disqus comments won’t work, as it’s disabled by default unless we’re in production. Next you can see a screenshot of the Netlify screen where we can set environment variables.

A way to simplify unit tests on static methods

Thu, 14 Sep 2017 18:08:49 +0000

Intro

This post will be simple and try to act as a discussion starter on unit testing static methods.

I’m not the greatest fan of making static stuff, mainly because I’ve been burned by it in the past (the fact is that static was being used badly in those cases, but even so, if I can, I’ll avoid it) but I understand it’s the best way to do things sometimes.

[Video] .NET performance curiosities

Mon, 11 Sep 2017 19:31:43 +0000

I added a new video, just talking about very simple stuff we do all the time that can have some impact on our applications performance, and the just as simple ways we can avoid these situations.

The source code for the sample is here at GitHub

[Video] Using Polly to improve .NET applications resilience

Sat, 29 Jul 2017 15:38:16 +0000

I added a new video, this time revisiting the subject of a past post: using the Polly library to handle errors and improve application resiliency.

The original post is here and you can check out the source code here on GitHub.

Cyaz

[Video] REST vs GRPC in C# just for fun

Mon, 17 Jul 2017 19:51:18 +0000

I haven’t posted in a while and today I felt like doing something different: a video!

I have no clue if this will turn out any good so, check it out and make sure to provide some feedback!

You can check out the source code here on GitHub.

[Redirect] How To Save The Princess In 8 Programming Languages

Sat, 12 Nov 2016 13:23:20 +0000

This is just too good not to share :)

Original

Simpler error handling in .NET applications using Polly

Tue, 08 Nov 2016 17:10:40 +0000

Just think how many times you had to write some code to handle errors, and that handling required more than just logging and proceed with life as if nothing happened. If retries are required, or a cool down time, that’s a good amount of logic to roll for those situations. Well, there’s a NuGet for that (I guess that’s our version of there’s an app for that).

Polly is a “library that allows developers to express transient exception and fault handling policies such as Retry, Retry Forever, Wait and Retry, or Circuit Breaker in a fluent manner.”

Boilerplate hunting with Castle DynamicProxy

Tue, 01 Nov 2016 18:29:00 +0000

Castle Core is a library that provides some utilities but I’ll just talk about using one of them, the DynamicProxy. If the post on BenchmarkDotNet was in the race for golden shovel award, a post on Castle DynamicProxy is a sure winner, but I feel like it :)

Castle DynamicProxy is a a “lightweight runtime proxy generator”, that enables you to do a kind of aspect oriented programming, allowing for some code to be executed before or after a method is invoked on a proxied interface. It’s useful for some cases, and I’ll talk about two of such cases: caching and timing operation execution times. We could also do this using for example decorators, implementing the same interface of the target class. The problem with the decorator approach is that we need to implement all the operations one by one, but with the DynamicProxy approach we can apply the same logic to all operations as long as it’s sufficiently generic.

[Redirect] How you should (not) use HttpClient

Thu, 27 Oct 2016 21:24:18 +0000

(The redirect tag in the title means this post is just a share of another post)

So, how do you use the HttpClient (.NET)? Like this?

using (var client = new HttpClient())
{
    var result = await client.GetAsync("http://xpto.com/api/stuff");
    //...
}

Well, so do I. And it’s wrong.

Check out this article that tells you all about why. tl;dr Use a singleton instance. Oh, and after that one, this is also a good (important) related read. (You’ll see that this second article makes my tl;dr a bit too short)

BenchmarkDotNet - Library for benchmarking .NET code

Mon, 24 Oct 2016 08:37:46 +0000

This will probably earn me what some friends of mine call a golden shovel (an award for finding out something everyone already knows) but since I just recently found out about it, I’ll write about it anyway.

Several times I felt the need to benchmark some portions of code so I could see if a way of doing something could be a slow down cause for an application (many of those times were when I wanted to use some reflection to simplify the code and some colleagues were afraid reflection was going to have a negative impact on performance). When I wanted to do that, I just wrote a console application, throw a bunch of Stopwatches around and put a loop around the code I wanted to test to get an average execution time.

Getting this up and running – Bonus round: SSL, Email and stuff (3/3)

Tue, 18 Oct 2016 08:32:37 +0000

To finish up this series of posts I’ll just go by a couple of extra things I needed to do to get the, mostly functional by now, site to work better.

The main points are:

Getting some certificates to get the site working on https.
Using a mail server to overcome an issue with WordPress running on Docker.

Get the site on HTTPS

Everybody likes (or should) when you go to a web site and it uses HTTPS, even more so when there are private stuff going down the wire (like user credentials).

Getting this up and running – Installing Docker and running applications with it (2/3)

Sat, 15 Oct 2016 08:12:28 +0000

This post will focus on installing the Docker engine and then running the applications we need to make the blog work as Docker containers.

I’m not the best to explain all about Docker, so I’ll focus on what I needed to do to get the blog running. If you really want to learn about Docker there are lots of good resources out there, starting with Docker’s own documentation (which I used a lot).

Getting this up and running – Initial server setup (1/3)

Sat, 08 Oct 2016 15:23:32 +0000

So this post is gonna be more of a “getting started with a virtual machine in a cloud provider” sort of thing, not very advanced, just a simple step by step guide for someone who never did it.

Cloud Providers

Like I said in the intro to this series of posts, I’m using Linode mainly for it being slightly cheaper than Digital Ocean (referred as DO from now on) which I was using before it. Until this point both options seem to be really solid, although I haven’t deployed nothing yet to really test how it performs under load.

Getting this up and running - Intro

Wed, 05 Oct 2016 11:08:21 +0000

So I guess a good article to begin with would be to explain how I got this site up.

Even more fitting is it has nothing to do with .NET, which you would expect would be on the debut article around this parts (rest assured those will come like a stampede :) ).

So, let me start by summarize how this thing is working:

The server is a Linode [1] virtual machine. I was on Digital Ocean [2], but for 10$, I get 2GB of ram on Linode versus 1GB on Digital Ocean, and ram is very much appreciated so I can put lots of stuff running at the same time.

"Time's up, let's do this! Leeeeeeeeeeeeeroy Jenkins!"

Mon, 03 Oct 2016 21:19:42 +0000

And with this legendary quote [1] , I open the hostilities in this new blog.

I’ve been thinking about creating something like this for a while, but the thought that probably I didn’t have much to add to the myriad of coding blogs and sites out there, and maybe a tad of laziness, has delayed me for a couple of years.

My main goal is to talk about specific problems I had and how I solved them. I’m sure most of the times I’ll post something seen elsewhere, but adjusted to my particular problems. Hopefully sometimes I can come out with something that’s not that easy to find through the interwebs. In summary, it’ll be like a log of some of the stuff I do, so I can get back to it later and maybe assist someone in the process (and probably learn from someone who chimes in to improve my shenanigans).

Contact

Mon, 01 Jan 0001 00:00:00 +0000

If you can’t get in touch through one of the channels listed in the footer, feel free to use this form.

I’ll try to get back to you as soon as possible.