Coding Militia

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.

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.

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

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

Another week, another bunch of links!

Have at it!

And we’re in for another round!

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

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…

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

A couple of reads and a couple of watches.

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

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

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

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

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.

Not a big list this week, as I’ve been working on my own posts most of the time.

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

Some more reading material.

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

Another pair of each to wrap up the weekend.

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

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

Have at it!

Here ye go!

Aaaaand it’s another round incoming!

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

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.

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

Slower week, a few more links anyways!

Here comes some more link goodness!

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

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

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.

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

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

Some more reading/watching material.

Here comes another round of interesting reads/watches.

Articles “Creating Domain-Driven Design entity classes with Entity Framework Core” Nice approach to implement domain driven design entity classes using EF Core.

Here comes another round of (interesting?)

Well, this is a very written about topic isn’t it?

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

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.

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.

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

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.

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.

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

This is just too good not to share :) Original

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.