• Creating an Azure Function ARM template

    Creating Azure functions is easy. Managing them can be a challenge. Much like microservices, functions can get problematic to maintain when having multiple environments. This is where Infrastructure as Code can help. Although I don’t particularly enjoy creating Azure Resource Manager (ARM) templates, I do enjoy the benefits of ARM. I can confidently say that my development environment is configured like production.

  • Creating a CI/CD pipeline for Azure Functions

    Azure functions are cute. You can fire up the online function editor from the Azure portal and start hacking away using many languages. In my case, I’d like to start writing some C# and being able to run it and debug it quickly. Eventually, I end up craving Visual Studio & ReSharper along with some unit tests.

  • Service Fabric vs Azure Container Service - Part 1: Introduction

    Azure Container Service vs Service Fabric

  • Understanding ASP.NET Core Middleware

    The more time I spend writing ASP.NET Core applications, the more I begin to experience how extensible it is. Besides first-class usage of dependency injection, the middleware is one of my favorite features. Understanding how middleware works, will give you insight into the flexibility and simplicity of the new framework.

  • Shhh, keep your secrets to yourself in ASP.NET Core

    Azure provides wonderful PaaS options for developers, especially those using .NET. In many cases, services like Azure Service Bus, require connection strings and secured tokens used to authenticate our applications. If you want to make your repository publicly accessible, it is not a good idea to include these connection strings and other sensitive bits of information as part of the source code.

  • RavenDB Lessons Learned - Part 2

    A continuation of my lessons learned on RavenDB. Some tips on testing and what not to do.

  • RavenDB Lessons Learned

    For the last 3 years, I’ve been using RavenDB in various projects. Most have been really positive experiences, but like any other technology, there’s going to be gotchas. Here’s a random collection of lessons learned from my point of view.

  • When Unit Tests are a Waste of Time

    Ever wonder if the tests you’re writing will pay off? Ever wonder if they’ll catch any regressions? Sometimes, they don’t. It’s not because TDD doesn’t work. It’s not because you’re bad at writing tests. When your requirements are just assumptions, your tests are a waste of time.

  • My VS Code Cheatsheet

    Recently, I finally got around to using VS Code more in my day to day. As of right now, I’m currently using it to write up this blog post using Jekyll and Markdown.

  • The Query Object and Repository Pattern

    The Repository Pattern has been around for a long time. According to a quick Google search, it predates the GoF patterns and the .NET framework. It’s understandable. Inline SQL was king and it was sprinkled as code behind in many apps. The Repository Pattern was seen as a way to tuck away all this logic and starting to structure and decouple applications a little better.

subscribe via RSS