Coding Militia

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

Microservices are all the rage for some time now, but are we using the right foundations to create them?

In this episode, we briefly introduce Apache Kafka, as we’ll use it to implement our event bus.

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.

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.

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.

As we start implementing event-driven integration, the first thing we need to do is publish the events.

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.

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 n…

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 refe…

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.

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.

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

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.

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).

In C# land, the abuse of services and DTOs is prevalent.

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

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.

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.

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.

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.

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.

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.

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

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.

In this episode, we take a look at our frontend single page application, and the changes made to handle user authentication.

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 cal…

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).

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

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

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

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.

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.

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

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

In this episode, we start building the authentication service, using ASP.NET Core Identity and Razor Pages.

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.

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.

In this episode, we start the frontend development with Vue.js.

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.

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

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.

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

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.

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.

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.

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

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.

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.

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 co…