My Sunday Reading List

Declarative vs Imperative

https://en.wikipedia.org/wiki/Declarative_programming
https://en.wikipedia.org/wiki/Imperative_programming

This is probably your interview questions, even though not many company I came across has asked these. Declarative programming vs imperative programming, is basically, in its very simple form, like functional programming vs object-oriented programming.


6 Key Concepts in Andrew Ng’s “Machine Learning Yearning”

If you want to learn Machine Learning, Andrew Ng is the man you need to listen to. There’s so much more to cover beyond this article, but it lays out 6 basic concepts in Machine Learning.


Using the Microsoft Graph API with PowerShell

A detail walkthrough on how to query Microsoft Graph API, which is a service to manage all most aspects of Azure AD and Office 365, with Powershell. From setting up secrets, certificate, application permission to access token, all covered here.


Why our team cancelled our move to microservices

Sometime you have to know when to back out as in this story of Steven’s team backing out from implementing microservices. What’s even more awesome is, he documented the lesson-learned from his team on what to consider when implementing microservices.


How you can build a Serverless API using GraphQL .Net Core, C# and VS Code

A step-by-step walkthrough on how to build GraphQL-based API with .Net Core, C# and Azure Functions.


Autofac Keyed Service Example

Note: Tested on Autofac 4.9.2.

Autofac Keyed Services provide convenience way to register multiple types of same interface with key identifier, see the documentation here.

It’s very useful feature when we want to choose between different implementations of same interface. See below for example:

`WebApiConfig.cs`
This is where we register our type in Autofac container.

var builder = new ContainerBuilder();

builder.RegisterType<CorporateService>()
    .As<IService>()
    .Keyed<IService>("Corporate");
builder.RegisterType<SchoolService>()
    .As<IService>()
    .Keyed<IService>("School");

GlobalContainer.Container = builder.Build();

`GlobalContainer.cs`
This is global object to store our container for resolving type later in application lifecycle.

using Autofac;

namespace QC
{
    public class GlobalContainer
    {
        public static IContainer Container { get; set; }
    }
}

`IService.cs`
This is sample service interface – don’t copy, make your own.

namespace QC.Service
{
    public interface IService
    {
        double GetRate();
    }
}

`CorporateService.cs`
This is sample service interface implementation – don’t copy, make your own.

namespace QC.Service
{
    public class CorporateService : IService
    {
        public double GetRate()
        {
            return 15;
        }
    }
}

`SchoolService.cs`
This is sample service interface implementation – don’t copy, make your own.

namespace QC.Service
{
    public class SchoolService : IService
    {
        public double GetRate()
        {
            return 10;
        }
    }
}

There are 2 options to resolve `IService` to type we desired (ie: Corporate or School).

1. Resolving Explicitly.
Documentation.

`CustomerController.cs`
Sample controller that choose which service to initiate.

using Autofac;
using QC.Service;
using System.Web.Http;

namespace QC.Controllers
{
    public class CustomerController : ApiController
    {
        [HttpGet]
        public IHttpActionResult GetRate()
        {
            // In real-world, we would have business logic to determine which service to initiate
            var service = GlobalContainer.Container.ResolveKeyed<IService>("Corporate");

            var rate = service.GetRate();
            return this.Ok(rate); // Return 15
        }
    }
}

2. Resolving with an Index (recommended).
Documentation.

`CustomerController.cs`

using Autofac.Features.Indexed;
using QC.Service;
using System.Web.Http;

namespace QC.Controllers
{
    public class CustomerController : ApiController
    {
        private readonly IIndex<string, IService> serviceIndexes;
        private readonly IService service;

        public CustomerController(IIndex<string, IService> serviceIndexes)
        {
            this.serviceIndexes = serviceIndexes;

            // In real-world, we would have business logic to determine which service to initiate
            this.service = this.serviceIndexes["Corporate"];
        }

        [HttpGet]
        public IHttpActionResult GetRate()
        {
            var rate = this.service.GetRate();
            return this.Ok(rate); // Return 15
        }
    }
}