DEV Community: Jin Vincent Necesario

Azure Management Groups 101

Jin Vincent Necesario — Fri, 10 Jul 2026 15:31:42 +0000

Introduction

As cloud computing advances, effective resource management becomes vital for organizations; that's why Azure Management Groups come into the picture, helping organizations to structure and organize their Azure resources and provide a hierarchical, efficient approach to resource management.

That’s why in this article, we’ll explore the key aspects of Azure Management Groups, including their functionalities, benefits, and best practices.

The Basics of Azure Management Groups

Azure Management Groups serve as a logical container for Azure subscriptions. It helps organizations to facilitate and centralize management, governance, and compliance.

Think of it as an organizational boundary that helps streamline the administration of multiple subscriptions within your Azure environment.

Tenant Root Group

The moment you sign up, or should we say upon first sign-up.
Azure automatically provisions the “Tenant Root Group,” which serves as the root/highest level in the Management Group hierarchy, encompasses the entire Microsoft Entra tenant, and serves as the starting point for organizing subscriptions and other Management Groups.

Management Groups and Subscriptions

The primary function of “Management Groups” is to manage Azure subscriptions efficiently.

Now, each subscription must be associated with a Management Group, either directly, under the “Tenant Root Group,” or nested within other Management Groups.

This type of hierarchical structure allows organizations to group subscriptions by business units, projects, or other criteria.

Control Access, Policies, and Compliance

The essential role of Azure Management Groups is to implement governance and compliance policies across the organization’s Azure environment.
Moreover, when applying policies at the Management Group level, the organization can enforce standards, regulations, and security controls consistently across all associated subscriptions.

Access control is also streamlined through Management Groups. This helps organizations grant permissions at the Management Group level, ensuring that users have the necessary access to resources within the associated subscriptions.

Inheritance within Management Groups

The Child Management Groups obviously inherit their policies and access controls from their parent. This hierarchical structure ensures uniformity in both governance and compliance across all levels.

A good thing to mention is that any modifications made at the higher level cascade down to Child Management Groups and their associated subscriptions.
Moreover, the hierarchical structure of Azure Management Groups allows organizations to create child Management Groups under the “Tenant Root Group” or under parent Management Groups, providing flexibility and enabling dynamic organization and adaptability to the business’s evolving needs.

Subscription Movements and Management Group Modifications

As business requirements change, organizations often need to adapt their resource structure. Azure provides this kind of capability, a capability to move subscriptions across different Management Groups, and this feature is significant when restructuring or optimizing resource division within an organization.

Now, for Management Group modifications, the child Management Groups are movable or can be deleted. This flexibility in adjusting its Azure environment is essential for maintaining an agile, responsive cloud infrastructure aligned with the organization’s goals and structure.

Best Practices for Azure Management Groups

We’ll try to provide some best practices to enhance our resource management capabilities and to ensure optimal usage and governance.

Establish a Thoughtful Hierarchy

It is vital to establish an effective hierarchy.
Imagine establishing a well-thought-out hierarchy that enables easy resource management.

It is good to remember that periodic review and adjustment of the hierarchy ensure that the structure aligns with current business objectives and facilitate ongoing optimization of resource management.

Implement Role-Based Access Control (RBAC)

Implementing Azure’s RBAC helps organizations enforce the principle of least privilege.

Assigning roles and permissions at the appropriate Management Group level to ensure users have access to the resources they need and are authorized for.

Utilize Policies for Compliance

Implementing Azure Policies at the Management Group level enforces compliance standards and security controls.

Now, this approach improves the organization’s capability to manage risk, adhere to regulatory requirements and maintain a secure cloud environment.

Conclusion

Azure Management Groups provide a structured way to organize subscriptions, apply governance controls, and maintain consistency across an organization’s Azure environment. Through hierarchy, inheritance, access control, and policy enforcement, they help organizations manage resources more efficiently while supporting security and compliance requirements.

As organizations continue to expand their cloud adoption, understanding and using Azure Management Groups is essential. By following best practices, organizations can build a well-organized, scalable, and compliant Azure environment that supports both current operations and future growth.

Stay tuned for more (keep visiting our blog and share this with your friends, colleagues, and network).

Until next time, happy programming!

Please don’t forget to bookmark, like, and comment. Cheers! And thank you!

String and StringBuilder in C#: Key Differences Explained

Jin Vincent Necesario — Sun, 21 Jun 2026 12:51:30 +0000

Introduction

In this post, we’ll explore the key differences between String and StringBuilder in C# so that you can optimize string operations in your projects effectively.

Before continuing, I recommend reading my C# Corner article, "Playing with C# Strings Instance Methods," which I wrote six years ago.

It remains closely related to this topic.

Let’s get started.

What is a string?

Bear in mind that a string is a collection, or array, of read-only characters.

In other words, it is a sequence of characters used to represent text and an object type in the System namespace.

Another thing, strings are immutable, meaning that once they are created, their content cannot be changed directly.

What is Immutability?

Within the context of C# and .NET, immutability design prevents accidental modification of shared data.

Understanding immutability, let’s say an object is considered immutable if its internal state cannot change after it is created. If changes are needed, a new object must be created rather than modifying the existing one; this applies to strings as well.

Okay, so we don't get confused, let's use an example.

[Fact]
public void String_Should_Not_Be_Changed_When_Concatenated()
{
    //arrange
    string original = "dev.to rocks!";

    //act 
    string modified = original + " but it is not the only one!";

    //assert
    Assert.Equal("dev.to rocks!", original);
    Assert.Equal("dev.to rocks! but it is not the only one!", modified);
}

[Fact]
public void String_Concatenation_Creates_New_Instance()
{
    string a = "Hello";
    string b = a;

    string c = a + "!";

    Assert.Same(a, b);      // same reference initially
    Assert.NotSame(a, c);   // new string instance created
}

What is StringBuilder?

If a string is immutable, then StringBuilderis the opposite: it is mutable.

StringBuilder represents a mutable sequence of characters, allowing its content to be changed.

The StringBuilder class provides this functionality and is available in the System. Text namespace.

Moreover, once you have created a StringBuilder object, you can perform certain operations like insert, replace, or append without creating a new instance every time you do it. Plus, it will update the string in a single place in memory and won’t allocate new space.

[Fact]
public void StringBuilder_Is_Mutable()
{
    // Arrange
    var sb1 = new StringBuilder("Hello");
    var sb2 = sb1; // Same object

    // Act
    sb1.Append(" World");

    // Assert
    Assert.Equal("Hello World", sb1.ToString());
    Assert.Equal("Hello World", sb2.ToString());
    Assert.Same(sb1, sb2);
}

[Fact]
public void Append_Should_Modify_Existing_Instance()
{
    // Arrange
    var sb = new StringBuilder("Hello");

    // Act
    sb.Append(" World");

    // Assert
    Assert.Equal("Hello World", sb.ToString());
}

Why are Strings immutable while StringBuilder is mutable?

Making strings immutable has several advantages; it provides automatic thread safety. It makes strings behave like an intrinsic type in a simple, effective manner, which also allows for extra efficiencies at runtime and huge security advantages, since it’s impossible for a third-party API call to change your strings.

That’s why StringBuilder was added to address the disadvantage of immutable strings. The runtime construction of immutable types causes a lot of Garbage Collector (GC) pressure and is inherently slow.

Deciding between String and StringBuilder

Here is a practical guide for choosing between String and StringBuilder, designed to help you understand their strengths and feel more in control of your code decisions.

Use a string for short, static, or rarely changing text.
Choose String when performance is not critical, and simplicity is preferred.

Use StringBuilder when building large or complex strings, especially with frequent modifications, to optimize speed and memory and make your code more efficient.

Summary

In this post, String and StringBuilder both handle text in C#, but as you can see, they have different uses in different scenarios.

As we have discussed, a String is immutable, meaning its value cannot be changed once created; any modification creates a new String object (a new instance). This provides benefits such as thread safety, reliability, and security, but it can affect performance when you intend to change. So, imagine the thousands of strings created at once.

While StringBuilder, on the other hand, is mutable and allows text to be modified directly through operations such as append, insert, and replace.
That’s why you should already remember to use String for simple, short, or rarely changing text, and choose StringBuilder when working with large, complex, or frequently modified strings where performance and memory efficiency matter.

Stay tuned for more (keep visiting our blog and share this with your friends, colleagues, and network).

Until next time, happy programming!

Please don’t forget to bookmark, like, and comment. Cheers! And thank you!

References

• https://dev.to/shreyans_padmani/string-vs-stringbuilder-in-c-understanding-the-difference-for-better-performance-3ge5
• https://www.c-sharpcorner.com/article/immutability-the-secret-weapon-for-reliable-c-sharp-applications/
• https://stackoverflow.com/questions/2365272/why-net-string-is-immutable
• https://www.c-sharpcorner.com/blogs/difference-between-string-and-stringbuilder-in-c-sharp1

Using EF Core In-Memory Database in ASP.NET Core Web API

Jin Vincent Necesario — Tue, 31 Mar 2026 16:50:57 +0000

I. Introduction

Have you been in a situation where you need to test a new feature with your web application without affecting the production database? Or maybe a fast prototype without setting up a whole new database.

And in this situation, you are thinking about an in-memory database, and you are right.

Didn’t you know that Entity Framework Core can help us with this situation without directly interacting with the underlying database provider?

This is where the EF Core In-Memory Database Provider comes into the picture, and where an in-memory database comes into play.

II. Chances That You Need to Use an In-Memory Database

Here are some scenarios where you need to use EF Core In-Memory Database.

Integration Testing

If you are into integration testing, you can use EF Core In-Memory Database.
Instead of mocking your repositories, you can use this EF Core In-Memory Database for a lightweight integration test.

Quick Demo

For a quick demo, validating an idea, or creating a fast spike solution, we can use in-memory to move fast without worrying about the underlying database setup.

Temporary Data Storage

If you don’t need persistence, it resets data on restart; thus, in-memory is enough for temporary data storage.

III. What is EF Core In-Memory Database Provider?

As we all know, Entity Framework Core helps developers store and retrieve data, but it also includes an in-memory database.

A database that resides in volatile memory instead of a physical disk.
To use this, we need to install Microsoft.EntityFrameworkCore.In-Memory NuGet package.

Moreover, this in-memory database is a quick and easy way to test your ASP.NET Core web applications, without the overhead of actual database operations.

IV. How to Use an In-Memory Provider?

Let’s try to do this step by step.

But before we start, please create a new Web API project, then follow the steps below.

First thing is to install Microsoft.EntityFrameworkCore.InMemory.
Or you can take a look at our project file (.csproj) for the package reference.

  <ItemGroup>
    <PackageReference Include="AutoMapper" Version="12.0.1" />
    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.25" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
  </ItemGroup>

Just a note here: we also use AutoMapper for entity-to-model mapping later.
Second, let’s create our entities.

namespace EFCoreInMemoryDbSamp.Entities;

public class Author
{
    public Guid Id { get; set; }
    public string FirstName { get; set; } = null!;
    public string LastName { get; set; } = null!;
    public DateTime BirthDate { get; set; }
    public ICollection<Book> Books { get; set; } = new List<Book>();
}

namespace EFCoreInMemoryDbSamp.Entities;
public class Book
{
    public Book(string title)
    {
        this.Title  = title;
    }
    public Guid Id { get; set; }

    public string Title { get; set; } = string.Empty;

    public string? Description { get; set; }

    public Guid AuthorId { get; set; }

    public Author? Author { get; set; }
}

Third, now that we have our Entities, let's try to create our DbContext.

using EFCoreInMemoryDbSamp.Entities;
using Microsoft.EntityFrameworkCore;

namespace EFCoreInMemoryDbSamp.Context;

public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
    {
    }

    public DbSet<Author> Authors { get; set; }

    public DbSet<Book> Books { get; set; }


    override protected void OnModelCreating(ModelBuilder modelBuilder)
    {

        modelBuilder.Entity<Book>()
            .HasOne(b => b.Author)
            .WithMany(a => a.Books)
            .HasForeignKey(b => b.AuthorId);

        base.OnModelCreating(modelBuilder);

    }
}

Fourth, we need a repository to obtain the authors’ information.

using EFCoreInMemoryDbSamp.Entities;

namespace EFCoreInMemoryDbSamp.Services;

public interface IAuthorRepository
{
    Task<IEnumerable<Author>> GetAllAuthorsAsync();

    Task<Author?> GetAuthorByIdAsync(Guid id);

    Task AddAuthorAsync(Author author);

    Task DeleteAuthorAsync(Guid id);
}

Now, let’s look at the implementation of the repository interface.

using EFCoreInMemoryDbSamp.Context;
using EFCoreInMemoryDbSamp.Entities;
using Microsoft.EntityFrameworkCore;

namespace EFCoreInMemoryDbSamp.Services;

public class AuthorRepository : IAuthorRepository
{
    private MyDbContext _context;

    public AuthorRepository(MyDbContext context)
    {
        this._context = context;
    }

    public async Task AddAuthorAsync(Author author)
    {
        await this._context.Authors.AddAsync(author);
        await this._context.SaveChangesAsync();
    }

    public async Task DeleteAuthorAsync(Guid id)
    {
        var author = await this._context.Authors.SingleOrDefaultAsync(a => a.Id == id);

        if (author != null)
        {
            this._context.Authors.Remove(author);
            await this._context.SaveChangesAsync();
        }
    }

    public async Task<IEnumerable<Author>> GetAllAuthorsAsync()
    {
        return await this._context.Authors.Include(item => item.Books).ToListAsync();
    }

    public async Task<Author?> GetAuthorByIdAsync(Guid id)
    {
        Author author = new Author();

        var result = await this._context.Authors..Include(item => item.Books).SingleOrDefaultAsync(a => a.Id == id);

        if (result != null)
        {
            author = result;
        }

        return author;

    }
}

Fifth, let’s create a model and an AutoMapperprofile to use in our controller.

namespace EFCoreInMemoryDbSamp.Model;
public class Author
{
    public Guid Id { get; set; }

    public string? FirstName { get; set; }

    public string? LastName { get; set; }

    public List<Book> Books { get; set; }
}

namespace EFCoreInMemoryDbSamp.Model;

public class Book
{
    public Guid Id { get; set; }

    public string Title { get; set; } = string.Empty;

    public string? Description { get; set; }

}

using AutoMapper;

namespace EFCoreInMemoryDbSamp.Model;

public class AuthorProfile : Profile
{
    public AuthorProfile()
    {
        CreateMap<Entities.Author, Author>();
    }
}

using AutoMapper;

namespace EFCoreInMemoryDbSamp.Model
{
    public class BookProfile : Profile
    {
        public BookProfile()
        {
            CreateMap<Entities.Book, Model.Book>();
        }
    }
}

Sixth, we need a controller; in this, we created an AuthorController.

using AutoMapper;
using EFCoreInMemoryDbSamp.Model;
using EFCoreInMemoryDbSamp.Services;
using Microsoft.AspNetCore.Mvc;

namespace EFCoreInMemoryDbSamp.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AuthorController : ControllerBase
    {
        private readonly IAuthorRepository _authorsRepository;
        private readonly IMapper _mapper;

        public AuthorController(IAuthorRepository authorRepository, IMapper mapper)
        {
            this._authorsRepository = authorRepository;
            this._mapper = mapper; 
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<Author>>> GetAuthors()
        {
            var authorsFromRepo = await _authorsRepository.GetAllAuthorsAsync();
            return Ok(_mapper.Map<IEnumerable<Author>>(authorsFromRepo));
        }

        [HttpGet("{authorId}")]
        public async Task<ActionResult<Author>> GetAuthor(
            Guid authorId)
        {
            var authorFromRepo = await _authorsRepository.GetAuthorByIdAsync(authorId);
            if (authorFromRepo == null)
            {
                return NotFound();
            }

            return Ok(_mapper.Map<Author>(authorFromRepo));
        }
    }
}

Seventh, we need to form data, so we create a database initializer.

using EFCoreInMemoryDbSamp.Entities;

namespace EFCoreInMemoryDbSamp.Context
{
    public static class DbInitializer
    {
        public static void Seed(MyDbContext context)
        {
            var authors = new List<Author>
            {
                 new Author()
                {
                    Id = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                    FirstName = "George",
                    LastName = "RR Martin",
                    Books = new List<Book>()
                    {
                        new Book("A Dance with Dragons")
                        {
                            Id = Guid.Parse("5b1c2b4d-48c7-402a-80c3-cc796ad49c6b"),
                            AuthorId = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                            Description = "A Dance with Dragons is the fifth of seven planned novels in the epic fantasy series A Song of Ice and Fire."
                        },
                        new Book("A Game of Thrones")
                        {
                            Id = Guid.Parse("d8663e5e-7494-4f81-8739-6e0de1bea7ee"),
                            AuthorId = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                            Description = "A Game of Thrones is the first novel in A Song of Ice and Fire, a series of fantasy novels by American author George R. R. ... In the novel, recounting events from various points of view, Martin introduces the plot-lines of the noble houses of Westeros, the Wall, and the Targaryens."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("da2fd609-d754-4feb-8acd-c4f9ff13ba96"),
                    FirstName = "Stephen",
                    LastName = "Fry",
                    Books = new List<Book>()
                    {
                        new Book("Mythos")
                        {
                            Id = Guid.Parse("d173e20d-159e-4127-9ce9-b0ac2564ad97"),
                            AuthorId = Guid.Parse("da2fd609-d754-4feb-8acd-c4f9ff13ba96"),
                            Description = "The Greek myths are amongst the best stories ever told, passed down through millennia and inspiring writers and artists as varied as Shakespeare, Michelangelo, James Joyce and Walt Disney.  They are embedded deeply in the traditions, tales and cultural DNA of the West.You'll fall in love with Zeus, marvel at the birth of Athena, wince at Cronus and Gaia's revenge on Ouranos, weep with King Midas and hunt with the beautiful and ferocious Artemis. Spellbinding, informative and moving, Stephen Fry's Mythos perfectly captures these stories for the modern age - in all their rich and deeply human relevance."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("24810dfc-2d94-4cc7-aab5-cdf98b83f0c9"),
                    FirstName = "James",
                    LastName = "Elroy",
                    Books = new List<Book>()
                    {
                         new Book("American Tabloid")
                         {
                            Id = Guid.Parse("493c3228-3444-4a49-9cc0-e8532edc59b2"),
                            AuthorId = Guid.Parse("24810dfc-2d94-4cc7-aab5-cdf98b83f0c9"),
                            Description = "American Tabloid is a 1995 novel by James Ellroy that chronicles the events surrounding three rogue American law enforcement officers from November 22, 1958 through November 22, 1963. Each becomes entangled in a web of interconnecting associations between the FBI, the CIA, and the mafia, which eventually leads to their collective involvement in the John F. Kennedy assassination."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("2902b665-1190-4c70-9915-b9c2d7680450"),
                    FirstName = "Douglas",
                    LastName = "Adams",
                    Books = new List<Book>()
                    {
                         new Book("The Hitchhiker's Guide to the Galaxy")
                         {
                            Id = Guid.Parse("40ff5488-fdab-45b5-bc3a-14302d59869a"),
                            AuthorId = Guid.Parse("2902b665-1190-4c70-9915-b9c2d7680450"),
                            Description = "In The Hitchhiker's Guide to the Galaxy, the characters visit the legendary planet Magrathea, home to the now-collapsed planet-building industry, and meet Slartibartfast, a planetary coastline designer who was responsible for the fjords of Norway. Through archival recordings, he relates the story of a race of hyper-intelligent pan-dimensional beings who built a computer named Deep Thought to calculate the Answer to the Ultimate Question of Life, the Universe, and Everything."
                        }
                    }
                }
            };

            if (!context.Authors.Any())
            { 
                context.Authors.AddRange(authors);
                context.SaveChanges();
            }
        }

        public static void StartSeed(this WebApplication app)
        {
            using (var scope = app.Services.CreateScope())
            {
                var context = scope.ServiceProvider.GetRequiredService<MyDbContext>();
                DbInitializer.Seed(context);
            }
        }
    }
}

Now, for our last step, go to Program.cs file and check the differences between your Program.cs file and add the related methods from our previous code samples.

using EFCoreInMemoryDbSamp.Context;
using EFCoreInMemoryDbSamp.Model;
using EFCoreInMemoryDbSamp.Services;
using Microsoft.EntityFrameworkCore;
using System.Text.Json.Serialization;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers().AddJsonOptions(options =>
{

    options.JsonSerializerOptions.PropertyNamingPolicy = null;
    options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;

});

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

//we need to add authorrepository 
builder.Services.AddScoped<IAuthorRepository, AuthorRepository>();

//we need to set the EF to use In Memory Database
builder.Services.AddDbContextFactory<MyDbContext>(options =>
{
    options.UseInMemoryDatabase("MyInMemory");
});

//we need to add automapper profiles
builder.Services.AddAutoMapper(typeof(AuthorProfile), typeof(BookProfile));

var app = builder.Build();

//we need some data when the application has started.
app.StartSeed();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

V. Limitations

Wow! We have seen how to use the In-Memory in EF Core, but please be aware that it has several limitations.

It will allow you to save data, but remember it is not a relational database, so no foreign key constraints, no joins enforced like SQL, so no relational behaviors.
It will allow executing queries in memory using LINQ-to-Objects, not SQL.
Transactions are either ignored or not truly enforced.

The simple rule of thumb is that EF In Memory is a fake database, like a mock, while SQL Server is the production truth.

VI. Summary

In this post, we have seen that setting up EF Core with an in-memory database is straightforward.

As we discussed, this can significantly enhance your testing capabilities by providing a quick, easy way to simulate database operations without the overhead of a full database setup.

This setup is ideal for unit tests or integration tests, quick demos, and temporary data storage, allowing you to test your data access code in isolation.

From there, a code sample was shown on how to get started with this kind of setup, and I hope you enjoyed it.
Let me know if you have any questions about the code sample in the comment section below.

If you want the full codebase, you can find it here on GitHub.

Stay tuned for more (keep visiting our blog and share this with your friends, colleagues, and network).

Until next time, happy programming!

Please don’t forget to bookmark, like, and comment. Cheers! And Thank you!

VII. References

• https://entityframeworkcore.com/providers-inmemory
• https://rmauro.dev/set-up-entity-framework-core-in-memory-store/
• https://learn.microsoft.com/en-us/ef/core/providers/in-memory/?tabs=dotnet-core-cli
• https://www.infoworld.com/article/2336587/how-to-use-ef-core-as-an-in-memory-database-in-asp-net-core-6.html

Understanding the Distinctions: PowerShell vs. Azure CLI

Jin Vincent Necesario — Thu, 26 Mar 2026 10:42:58 +0000

Introduction

In today's cloud computing era, Microsoft Azure is known as one of the leading cloud providers, offering a range of services to meet businesses' dynamic needs.

Two powerful tools frequently used in the Azure ecosystem are PowerShell and Azure Command-Line Interface (CLI).

While both serve the common goal of managing and automating tasks in Azure, they differ significantly in their approach, syntax, and capabilities.

So, let’s explore these two by starting with PowerShell, then the Azure CLI.

Hopefully, by the end of the article, you’ll agree that both of these tools should be learned when working with Azure.

PowerShell: The Power Behind Scripting

Microsoft developed PowerShell, a task automation framework and scripting language.

It is a powerful command-line interface and a scripting environment that enables users to automate tasks and manage configurations.

One of the standout features of PowerShell is its object-oriented nature, which allows the output of one command to be used seamlessly as input to another.

This object-oriented approach makes PowerShell scripts highly versatile and flexible.

Let’s discuss some attributes of PowerShell below.

Cross-Platform Support

Before we discuss other PowerShell attributes, I think it is worth noting that PowerShell is cross-platform.

However, it was initially designed for Windows environments, and PowerShell has evolved to support cross-platform use through PowerShell Core (now known as PowerShell 7), allowing users to run PowerShell on Linux and macOS, broadening its applicability across operating systems.

That’s why it is recommended to install PowerShell version 7 side by side with PowerShell (Windows).

Syntax and Scripting

For readability, PowerShell uses a Verb-Noun naming convention for its commands, which provides a consistent structure.

For example, cmdlets like Get-AzVM or New-AzResourceGroup follow this convention.

PowerShell for Windows, its scripting language, is built on the .NET framework.

In contrast, PowerShell Core (now known as PowerShell 7) is built on .NET Core, making it a robust, extensible tool for automating and managing Azure resources.
Integration with Azure

We can integrate Azure directly from PowerShell by installing the Azure PowerShell module, which provides cmdlets for various Azure services, making it a preferred choice for Windows-centric environments and users familiar with PowerShell scripting.

Integration with Azure

If you would like to know more about installing the Azure PowerShell module, here are some links for guidance:
• https://github.com/Azure/azure-powershell
• https://learn.microsoft.com/en-us/powershell/azure/install-azps-windows?view=azps-15.4.0&tabs=windowspowershell&pivots=windows-psgallery
• https://learn.microsoft.com/en-us/powershell/azure/troubleshooting?view=azps-15.4.0#az-and-azurerm-coexistence.

Azure CLI: The Command-Line Interface Approach

Now that you are in this section, you might be thinking that Azure CLI is cross-platform.

Yes, you are right, it is a cross-platform command-line tool that focuses on simplicity and ease of use, providing a consistent experience across different operating systems.

Azure CLI commands are designed to be concise and follow a logical structure.

Syntax and Scripting

The verb-noun structure, similar to PowerShell, is also used by Azure CLI commands, but with a more straightforward, concise approach.

For instance, commands like az vm list or az group create follow this convention. The scripting language is based on JSON, making it easy to understand and write scripts for Azure resource management.

Integration with Azure

Azure CLI is built to be a lightweight and efficient tool for managing Azure resources.

Not only that, it offers a wide range of commands for various Azure services, giving users the flexibility to interact with Azure resources through a familiar command-line interface.

This is the tool of choice for users who prefer a streamlined, consistent experience across platforms.

Cross-Platform Support

The main strength of Azure CLI is its native cross-platform support, which works seamlessly on Windows, Linux, and macOS, making it a perfect choice for users working in different environments.

Choosing the Right Tool

We are now in a section that lets us choose between PowerShell and Azure CLI.

Well, everything depends on users’ likes and comfort levels with both.

PowerShell will always be favored by those who are comfortable with scripting, prefer a more comprehensive, object-oriented approach, or excel in complex automation scenarios.

On the other hand, Azure CLI appeals to users seeking simplicity and consistency in their command-line interactions, and its easy-to-understand syntax makes it an excellent choice for quick tasks and those who prefer a more command-oriented approach.

Conclusion

When using Azure in a day-to-day setting, the choice between PowerShell and Azure CLI boils down to individual preferences and, of course, the complexity of the tasks at hand.

If the user is comfortable with Windows environments, PowerShell's object-oriented scripting capabilities make it a perfect choice for automating and managing Azure resources.

However, if you are seeking a consistent, efficient command-line experience across operating systems, Azure CLI is your choice.

The best advice is to master both tools so users can navigate the Azure ecosystem with greater flexibility and efficiency.

Until next time, happy programming, and good luck with your career!

Understanding Azure Resource Manager and Its Components

Jin Vincent Necesario — Sun, 22 Feb 2026 04:11:28 +0000

A Beginner’s Guide to Resource Groups, Providers, Types, and Templates

Introduction

As a developer working with Azure, we need to understand the Azure Resource Manager, which provides a management layer for other APIs. We can distinguish it from an ARM template and understand its relation to Azure Resource Group, Resource Type, and Resource Provider.

Honestly, when I first started with Azure and began to understand Azure Resource Manager, I thought ARM and ARM templates were the same thing, but they’re not.

In this post, I’ll explain my understanding of Azure Resource Manager, Resource Group, Resource Provider, Resource Type, and Azure Resource Manager Template, as well as their differences.

So let’s get started.

What is Azure Resource Manager?

In my understanding, ARM serves as the management layer for all resources in Azure.

Moreover, it provides a unified API surface that the Azure Portal, Azure CLI, Azure PowerShell, and REST clients use.

Furthermore, ARM communicates with resource providers (e.g., Microsoft Compute, Microsoft Storage, etc.) to provision and manage resources, allowing us to think of ARM as the control tower of Azure.

What is a Resource Group?

A resource group enables you to organize resources logically and serves as a primary management boundary for Microsoft to deploy, monitor, and manage resources in Azure.

Two key takeaways from grouping resources: first, categorize them by the application life cycle (e.g., dev, test, qa, preprod, and prod); and second, organize them by organizational structure, such as specific departments or locations within an organization.

Additionally, the application life cycle keeps different environments isolated, making RBAC, cost tracking, and policies a bit easier (in my opinion).

Here are some things to keep in mind about resource groups.

It is free; the resource group doesn’t cost anything and is not considered a resource itself.
A resource group doesn’t serve as a communication barrier between other resource groups.
A resource can only occupy one resource group and cannot be in multiple resource groups.

What are Resource Providers and Types?

About this concept, Resource Providers in Azure make specific categories of resources available, such as compute, storage, networking, or databases.

Imagine that it is a service that supplies resource types.

For example:

Microsoft.Compute – it provides VMs, VM scale sets, disks, and snapshots
Microsoft.Network – it provides VNets, NICs, and load balancers
Microsoft.Storage – it provides storage accounts, blob containers, and file shares.

Now, resource type is the specific type of resources within the resource provider category.

For example, let’s say the resource provider is “Microsoft.Compute”, resource types could be “virtualMachines”, “disks”, “snapshots”, and “availabilitySets”.

The key thing to remember is that “Resource Provider” is a broad service category, while “Resource Type” is a specific kind of resource within the provider.

In contrast, the “Resource Instance” is your actual deployed thing in the cloud.

What is an ARM Template?

We won’t be tackling a lot of ARM templates here, but I’ll try to give at least a good background for us to understand them.

Fundamentally, an ARM template is a JSON file that describes the state of an infrastructure, because its primary purpose is to provision and configure resources in Azure.

Moreover, it is an Infrastructure as Code (IaC) that tells ARM what to build and manage.

A good analogy would be that an ARM template is the blueprint you submit to ARM, and ARM ensures the construction happens as specified.

Now that we have a good understanding of the difference between ARM and ARM templates, I would like to reiterate that Microsoft today recommends Bicep instead of writing raw ARM templates. However, under the hood, Bicep compiles down to ARM templates.

Characteristics of ARM Templates

Now that we have a good understanding of what an ARM template is, let’s discuss its characteristics here.

Idempotent

I still recall an interview where I struggled to explain a concept (I got a mental block). However, after learning from that experience, I can confidently say that if you run the same template multiple times, the result will be the same.

So, here’s how it works:

When you deploy, ARM compares the template’s desired state vs the current state of resources.
Then, if a resource exists and matches, no change at all.
Then, if a resource exists but differs, ARM updates it to match it.
Then again, if a resource doesn’t exist, ARM creates it.

Declarative

As you describe the end state, not steps, that’s why it is a declarative thing.

In imperative tools like Azure CLI, you instruct Azure on how to perform tasks step-by-step.

Thus, ARM templates say what it should look like.

Template Driven

As a JSON template file drives the template, you define things such as resources, parameters, variables, etc. Thus, it makes deployments reusable, automatable, and consistent.

Multi-service, Multi-region, Extensible

A single ARM template can deploy virtual machines, databases, storage accounts, networking, and other resources — enabling end-to-end solutions.

Templates are multi-region, since they can target resources across different regions within the same deployment.

Templates are also extensible, allowing you to nest or link templates for modularization. Additionally, ARM continuously evolves to support new resource types and services as they are released.

Summary

In this post, we have discussed ARM, Azure Resource Group, Azure Resource Provider, Azure Resource Type, and Azure templates.

I hope you learned a lot as I shared my knowledge and understanding here. Sometimes it’s easier to understand when I write things down in my head.

Once again, I hope you have enjoyed this article as I have enjoyed writing it.

Stay tuned for more. Until next time, happy programming!

Please don’t forget to bookmark, share, like, subscribe, and comment.

Cheers! And thank you!

Azure Resource Locks Explained: CanNotDelete vs ReadOnly

Jin Vincent Necesario — Wed, 18 Feb 2026 15:35:50 +0000

Protect Your Production Resources from Accidental Deletion

Photo by Pasqualino Capobianco on Unsplash

Introduction

Have you ever wondered that when working in cloud environments, specifically Microsoft Azure, there’s a possible deletion or even modification of resources, which is more common than you think.

Even a simple click, a misconfigured script, or an automated pipeline error can take the entire production down.

Now, that’s where Azure Resource Locks come in: they provide a built-in safety mechanism that protects your critical resources from accidental changes, even by users with high-level permissions.

So, if that gets you interested, let’s get started.

What is Azure Resource Lock?

We can define Azure Resource Lock as a Microsoft Azure management feature that prevents resources from being accidentally deleted or modified.

Moreover, based on our definition, it appears to be a layer on top of Azure Role-Based Access Control (RBAC).

Furthermore, we need to be aware that even users with the owner role cannot delete or modify a resource if a lock is applied.

Types of Azure Resource Locks

Now, in this section, let’s try to explore the different types of Azure Resource Locks.

CanNotDelete

This CanNotDelete (Delete Lock) prevents deletion of a resource but still allows modifications, which is ideal for production databases, storage accounts, or key vaults.

A good example is to allow developers to update configurations while preventing the deletion of a production database.

ReadOnly Lock

This ReadOnly Lock prevents both deletion and modification, effectively granting all users “Reader-level” access to the resource, and even scripts and automation cannot modify it.

A good example of this is, let’s say, you want to freeze a configuration in production to ensure no changes happen during an audit.

Where To Apply Resource Locks?

It can be applied to multiple scopes, including management groups, subscriptions, resource groups, and individual resources (e.g., VMs, Storage Accounts, SQL Databases).

A Good Sample Video Demo

Why Azure Resource Lock Matters in Real-World Projects?

There could be many reasons, but I can give you two things in this kind of question.

First, protection against accidental deletion: a good example is production databases in Microsoft Azure, such as Azure SQL Database, which can be protected from accidental deletion.

Second, defense against automation errors, let’s say there’s a faulty DevOps pipeline using ARM, Bicep, or Terraform, that cannot delete locked resources.

Do you want more?

Okay, last thing on my mind: audit and compliance in an enterprise-level company with regulated environments are critical for protecting production assets.

Summary

In this article, we discussed the ReadOnly Lock and CanNotDelete Lock, which are simple yet powerful features that can prevent catastrophic mistakes.

As engineers, we often focus on performance, scalability, and architecture — but operational safety is just as important. A single lock can prevent downtime, data loss, and hours of stress.

Whether you’re preparing for Azure certifications such as AZ-900 or working in production environments, understanding resource locks is essential.

Before the kubectl: A Beginner’s Guide to the Kubernetes Control Plane

Jin Vincent Necesario — Wed, 16 Jul 2025 16:28:03 +0000

Before you deploy, understand what’s going on behind the scenes inside the control plane.

Photo by Kazuo ota on Unsplash

I. Introduction

Learning Kubernetes is quite fun.

However, going directly to the CLI and running the kubectl commands, then experimenting with pods, deployments, and services without understanding what’s inside the Kubernetes cluster might still cause some confusion about how things work.

That’s why we’ll try to explore the cluster in Kubernetes and, of course, the control plane and its components.

Later in the article, we’ll attempt to run a cluster and show these components within the cluster using minikube.

II. What is a Cluster in Kubernetes?

To understand the entire cluster, we need to discuss the control planes (including their subcomponents) in the next section, as well as the worker nodes and pods. However, let’s define what a cluster is first.

Let’s not be too technical here; we can clearly define that the cluster is the whole system itself.

Moreover, a Kubernetes cluster comprises a control plane (the brain that runs the show) and a set of worker machines, known as worker nodes, that run containerized applications.

Furthermore, worker nodes host the pods that comprise the application workload.

As we have mentioned, the control plane is the brain that runs the show; it controls the worker nodes and the pods in the cluster.

To visualize what we have discussed, refer to the image below, courtesy of Kubernetes.

Kubernetes Cluster Architecture

III. What is a Control Plane and its Components?

Again, as we have mentioned, the control plane is the brain that runs the show, but it is a collection of numerous components that help us in handling the overall health of a cluster.

Four components/services run on the control plane; let’s discuss them one by one.

1. kube-apiserver

This kube-apiserver is part of the control plane and is constructed in accordance with the REST standard. REST proves highly efficient in showcasing functionalities through HTTP endpoints, which are accessible by employing various methods of the HTTP protocol, including GET, POST, PUT, PATCH, and DELETE. Due to these endpoints, you can interact with Kubernetes by calling this REST API through the kubectl command-line tool or direct API calls.

2. etcd

Kubernetes uses etcd to store state. It is an open-source, distributed key-value store used to store and manage critical information that distributed systems need to operate.

3. kube-scheduler

The kube-scheduler queries the kube-apiserver at regular intervals to list pods that have not been scheduled or have an empty nodeName property. It is responsible for electing a worker node out of those available to run a newly created pod.

4. kube-controller-manager

The kube-controller-manager is a significant component; essentially, its primary duty is to reconcile the actual state of the cluster with the desired state of the cluster stored in etcd.

IV. Run minikube and create a Cluster and show the Control Plane Components.

The objective of this section is to illustrate the control plane components and their respective locations when creating a new cluster.

Okay, let’s get started.

First, run the command minikube start — cpus 2 — memory 4096 .

This command will help you create a new cluster.

When everything is done, you’ll see something like this below.

However, we need to check the status just to be sure.

You can type the command minikube status and see output similar to the one below.

Now, how can we inspect and see the control plane?

Try running the command kubectl get nodes -o wide and see output similar to the one below.

Looking at the role, it serves as a control plane ; now let’s try to identify those components.

To view these components, type kubectl get pods -n kube-system and see output similar to the one below.

Additionally, this may be a bonus for the reader.

If ever you are curious, you can go to /etc/kubernetes/manifests to see the manifest files.

Showing:

kube-apiserver.yaml
kube-scheduler.yaml
kube-controller-manager.yaml
etcd.yaml

V. Summary

I hope you like this post. I created it to review my understanding of Kubernetes cluster and control plane components. Perhaps I’ll write more about Kubernetes shortly.

A few key takeaways: A Kubernetes cluster is the entire system itself, but the brain is the control plane, which comprises four components that work together to control the worker nodes and the pods.

This information, code, or software is provided for informational purposes only. It should not be considered professional coding or legal advice. Not all code or information provided may be accurate or suitable for your project. Consult a software development expert or legal professional before making significant coding or legal decisions.

Understanding and Implementing CORS in .NET Core Web API

Jin Vincent Necesario — Sun, 13 Jul 2025 18:14:54 +0000

Understanding and Implementing CORS in .NET Core Web API

A practical guide to solving cross-origin issues and securing your web APIs for modern frontend frameworks.

Photo by Karen Chew on Unsplash

Introduction

If you have been working on different projects for a while now, you’ll know that front-end applications frequently interact with backend APIs. However, since backends are hosted on other domains or ports, this decoupled architecture is resilient but presents a challenge: CORS (Cross-Origin Resource Sharing).

In this post, we’ll explore what CORS is, why it matters, and how to implement it correctly in a .NET Core Web API project.

What is Same-Origin Policy?

It’s a good idea to discuss this first before we define CORS, so let’s get started.

Same-Origin Policy is a security mechanism imposed by modern web browsers to prevent web pages from requesting a different origin than the one that served the page.

Let’s review a bit what “origin” means:

The protocol is either HTTP or HTTPS
The domain, e.g., medium.com
The port, e.g. 80,4200, 443

For these three parts to match, they must be considered to be of exact origin.

Let’s say a frontend application that runs at http://localhost:4200 wants to access a backend API that runs at https://localhost:5000.

Since these are not in the exact origin due to different ports, the browser blocks the frontend from accessing the backend by default.

What is CORS?

CORS (Cross-Origin Resource Sharing) is a browser security feature that restricts a web application from making HTTP requests to a different origin (domain, protocol, and port) than the one that served the web page.

The main goal of CORS is to:

Protect users from cross-site attacks, such as CSRF or data leaks.
Provide controlled access to resources on a different origin by specifying which origins are allowed to access the server.

This mechanism ensures that only trusted sources can communicate with your backend.

To recap, the Same-Origin Policy is enforced by the browser, which is the default behavior (checking if the request is going to the exact origin); if the request is to the same origin, it allows the request to proceed.

However, if not, it needs to check if CORS (on the target server) is configured, and the backend must respond with the correct CORS header; the browser will then allow the response.

Good Practices for Using CORS

First, avoid using “*” in production, as it can introduce numerous issues. Therefore, it is essential to permit only specific known domains. Hence, you need to allowlist trusted origins only.

Secondly, permit only the required methods, such as GET and POST, for your API, which means you need to restrict your HTTP methods.

Third, define the necessary request headers exclusively to minimize attack vectors and avoid using AllowCredentials() unless necessary.

Remember that this function allows cookies or HTTP authentication headers to be sent. Use it judiciously and never pair with “*” origin.

Implement CORS in .NET Core Web API

Let’s take a look at the code sample below.


using CORSPolicySample;

var builder = WebApplication.CreateBuilder(args);
var config = builder.Configuration;
// Add services to the container.

builder.Configuration.AddKeyVaultConfiguration();

builder.Services.AddControllers();

builder.Services.AddCors(options =>
{
    var originValues = config.GetSection("AllowedOrigins").Value ?? "";

    if (string.IsNullOrEmpty(originValues))
    {
        return;
    }

    var valuesInArray = originValues.Split(",");

    options.AddPolicy("AllowedOrigins", builder =>
        builder.WithOrigins(valuesInArray).AllowAnyHeader().AllowAnyMethod());

    //Restrict HTTP Methods
    options.AddPolicy("PublicApi", builder =>
        builder.AllowAnyOrigin().WithMethods("Get").WithHeaders("Content-Type"));
});

var app = builder.Build();

app.UseCors("AllowedOrigins");

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

If you are interested in this line of builder.Configuration.AddKeyVaultConfiguration.

Here is the code sample below.

namespace CORSPolicySample;

public static class KeyVaultConfigLoader
{
    public static void AddKeyVaultConfiguration(this ConfigurationManager config)
    {
        config.AddAzureKeyVault(
            new Uri("https://azurekeyvaulttestjin02.vault.azure.net/"),
            new DefaultAzureCredential());
    }
}

I created a key vault to store the allowed hosts for my application.

So you’ll see that this is the value for the allowed hosts: “http://localhost:4200,http://localhost:3000,http://localhost:5173,http://localhost:8080”.

However, in case Azure Key Vault is not needed, we can always use the appsettings.json file.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Conclusion

In this post, we have tackled and learned that CORS is a concept for building secure web APIs, which can be achieved by configuring CORS properly inside your .NET Core Web API.

This ensures a safe and controlled communication between your frontend and backend application without compromising the user’s security.

OOP in JavaScript: Prototype vs Class

Jin Vincent Necesario — Sat, 05 Jul 2025 10:56:25 +0000

A beginner-friendly guide to how objects and inheritance work in JavaScript.

Photo by Growtika on Unsplash

Introduction

JavaScript remains one of the most popular languages today, and it often confuses people when discussing Object-Oriented Programming (OOP) within it.

You may be asking, “Why”? It is because JavaScript uses prototype-based OOP, not the traditional class-based OOP like Java or C#.

People are thinking about TypeScript.

To remove the confusion.

Since TypeScript is a superset of JavaScript, it fully respects JavaScript’s underlying prototype-based inheritance model.

Still, TypeScript adds class-based OOP features (like in Java or C#) for cleaner syntax and static typing, but it doesn’t remove or replace prototypes — everything still compiles down to JavaScript.

Saying this just to be clear.

What is OOP?

This section could be a good review or refresher for those who are already experts.

OOP stands for Object Oriented Programming, a way of writing code where you group related data and functions into objects.

These objects can hold data known as properties, can perform actions known as methods, and inherit from other objects.

In traditional languages like C#, we can create a class as a blueprint, then create objects from that class.

Think of it like baking cookies from a mold.

public class Vehicle
{
    public string Name { get; set; }
    public int Speed { get; set; }
    public void Accelerate(int increaseSpeed)
    {
        if (increaseSpeed > 0)
        {
            this.Speed = this.Speed + increaseSpeed;
        }
    }
}

public class Truck: Vehicle
{
    public void Break(int decreaseSpeed)
    {
        if (decreaseSpeed > 0)
        {
            this.Speed = this.Speed - decreaseSpeed;
        }
    }
}

From our example above, it is a straightforward class in C#.

What’s Happening in ES6 Classes?

In TypeScript or JavaScript (ES6 onward), we can now use a similar class-based style.

Let’s try to mimic the example from C#.

class Vehicle {
  constructor(name, speed = 0) {
    this.name = name;
    this.speed = speed;
  }

  accelerate(increaseSpeed) {
    if (increaseSpeed > 0) {
      this.speed += increaseSpeed;
    }
  }
}

class Truck extends Vehicle {
  brake(decreaseSpeed) {
    if (decreaseSpeed > 0) {
      this.speed -= decreaseSpeed;
    }
  }
}

// Example usage:
const myTruck = new Truck("Fuso", 40);
myTruck.accelerate(20);
console.log(`${myTruck.name} speed: ${myTruck.speed}`); // Fuso speed: 60
myTruck.brake(10);
console.log(`${myTruck.name} speed: ${myTruck.speed}`); // Fuso speed: 50

Looks great? Right?

Now, here’s the twist: before ES6, JavaScript didn’t have class.

That’s why in the old days, creating a similar example would be built using functions and prototypes.

Moreover, this class syntax in ES6 is a syntactic sugar — it makes the code easier to write and read, especially for developers like us who came from class-based languages like C# or Java.

Furthermore, the ES6 class under the hood translates into prototype chaining.

Therefore, JavaScript (ES6) still employs prototype-based inheritance internally, even with the use of syntactic sugar in the form of classes.

That’s a good understanding of it, still, or will be a good thing under your belt.

Prototype-Based Version of Vehicle and Truck

Let’s try to see the example converted into the original prototype-based version of the vehicle and truck.

// Constructor function for Vehicle
function Vehicle(name, speed = 0) {
  this.name = name;
  this.speed = speed;
}

// Add method to Vehicle's prototype
Vehicle.prototype.accelerate = function(increaseSpeed) {
  if (increaseSpeed > 0) {
    this.speed += increaseSpeed;
  }
};

// Constructor function for Truck (inherits from Vehicle)
function Truck(name, speed) {
  // Call Vehicle constructor
  Vehicle.call(this, name, speed);
}

// Set Truck prototype to inherit from Vehicle's prototype
Truck.prototype = Object.create(Vehicle.prototype);
// Fix constructor reference
Truck.prototype.constructor = Truck;

// Add method to Truck prototype
Truck.prototype.brake = function(decreaseSpeed) {
  if (decreaseSpeed > 0) {
    this.speed -= decreaseSpeed;
  }
};

// Example usage:
const myTruck = new Truck("Fuso", 40);
myTruck.accelerate(20);
console.log(`${myTruck.name} speed: ${myTruck.speed}`); // Fuso speed: 60
myTruck.brake(10);
console.log(`${myTruck.name} speed: ${myTruck.speed}`); // Fuso speed: 50

As we have converted our example, the first thing to note is that there’s no class; it uses constructor functions and, of course, prototypes are manually implemented.

Moreover, it is verbose, but it provides a clear view of how inheritance works in JavaScript.

If you try to run the code sample, you’ll see something similar to this, see the screenshot below.

As you can see, the inheritance is done by linking prototypes; the internal property [[Prototype]] points to another object.

This prototype chain syntax is complicated to read, but it can be modified at runtime with flexibility.

Summary & Key Takeaways

JavaScript is prototype-based at its core.

Even though ES6 introduced class syntax, it’s just syntactic sugar over the prototype-based inheritance system that JavaScript has always used.

ES6 classes look familiar to developers with backgrounds in Java, C#, or TypeScript, which improves code readability and structure; however, under the hood, it’s still all about prototypes.

TypeScript provides a class-based feel with static typing, but it compiles down to JavaScript, meaning prototypes are still in effect—nothing magical, just a developer-friendly layer.

Understanding how both class-based and prototype-based OOP work in JavaScript helps you:

Debug more effectively
Write more optimized and flexible code
Appreciate how modern JavaScript builds on its core foundations

Final Note

Whether you prefer writing in ES6 classes or the old-school prototype way, knowing what’s happening under the hood gives you a serious edge as a JavaScript developer.

Understanding Azure Resource Manager: A Comprehensive Overview

Jin Vincent Necesario — Thu, 08 Feb 2024 02:29:50 +0000

Photo by Microsoft Edge on Unsplash

Introduction

When learning Azure, by experience, I must use the portal when personally learning and exploring other services.

However, as time passed, I recognized other ways to create resources in Azure, such as CLI, SDKs, PowerShell, etc.

Imagine how Azure Resource Manager is managing all of these.

That’s why it provides a unified management layer for all resources in your Azure environment, enabling you to deploy and manage applications consistently and efficiently.

In this article, we’ll explore what Azure Resource Manager is, the tools that interact with it, and its characteristics.

Let’s get started then.

What is Azure Resource Manager?

Before we define Azure Resource Manager, please see the image below so we’ll know how it works.

Azure Resource Manager

Now that we have seen the image above.

Let’s define Azure Resource Manager.

It is a management framework that allows you to deploy and manage resources in Azure.

These resources may include virtual machines, storage accounts, networking components, etc. ARM templates, written in JSON (JavaScript Object Notation), define your needed resources and their configuration.

Moreover, ARM templates are the building blocks for consistently deploying and managing resources across your Azure environment.

Tools that Interact with Azure Resource Manager

Several tools integrate with Azure Resource Manager to facilitate resource management, deployment, and monitoring.

Here are some essential tools and their roles.

Azure Portal

It is a web-based management interface.
Azure Portal is a user-friendly web interface that allows users to interact with Azure services.
It provides a graphical representation of resources and offers point-and-click resource management.

Azure PowerShell

It is a command-line interface, enabling the automation and scripting of Azure resource deployment and management tasks.
It uses cmdlets to interact with ARM and perform various operations.

Azure CLI (Command-Line Interface):

It is a cross-platform command-line tool.
It supports scripting and automation using Bash or PowerShell scripts.

Azure DevOps

It is a CI/CD platform.
Azure DevOps provides development tools for building, testing, and deploying applications.
It integrates with ARM to automate infrastructure deployment as code and application code.

Azure Resource Explorer

It is a resource visualization and exploration to understand the structure of Azure resources.
It provides a detailed view of resource properties and relationships.

Azure REST API

It is a programmatic access to Azure services.
Azure Resource Manager exposes a REST API that allows developers to interact with Azure resources programmatically.
This API is the foundation for various SDKs and tools.

Characteristics of Azure Resource Manager

Now that we have seen that some tools can interact with Azure Resource Manager let’s explore their essential characteristics.

Template-based Deployment

ARM relies on templates written in JSON to define the desired state of resources.

This declarative approach ensures consistency in resource deployment across different environments.

Resource Group Concept

In Azure, resources are logically grouped into resource groups, enabling the organization, management, and monitoring of related resources as a single unit.

Role-Based Access Control (RBAC)

ARM provides RBAC, which allows administrators to define fine-grained access controls for resources that ensure that users and services have the proper permissions to perform specific actions on resources.

Dependency Management

ARM intelligently handles resource dependencies.

It automatically determines the correct order for deploying resources based on their dependencies, streamlining the deployment process.

Tagging and Metadata

Resources in ARM can be tagged with metadata, providing additional information for organization and management.

Tags help in categorizing resources and simplifying the process of resource tracking.

Rollback and Roll Forward

ARM supports automatic rollback in case of deployment failures. If an error occurs during deployment, ARM can revert the changes to the last known good state.

Additionally, it allows for rolling forward to a desired state.

Template Validation

Ideally, administrators should validate ARM templates before deployment to ensure they adhere to the Azure Resource Manager schema, which helps catch errors and inconsistencies early in the development lifecycle.

Multi-Region and Multi-Environment Support

ARM enables the deployment of resources across multiple Azure regions, and templates can use parameters for different environments, such as development, testing, and production.

Summary

Azure Resource Manager is crucial in efficiently managing and deploying resources in Microsoft Azure.

With its template-based approach, extensive tooling support, and critical characteristics like RBAC and dependency management, ARM provides a robust framework for organizations to embrace infrastructure as code and streamline their Azure operations.

As cloud environments evolve, Azure Resource Manager remains a cornerstone for achieving consistency, reliability, and scalability in resource management.

This information or code or software is provided for informational purposes only. It should not be considered as professional coding or legal advice. Not all code or information provided may be accurate or suitable for your specific project. Consult a software development expert or legal professional before making any significant coding or legal decisions.

Understanding the Business Domain in Programming, Microservices, and .NET

Jin Vincent Necesario — Mon, 27 Nov 2023 02:17:56 +0000

Understanding the Business Domain in Programming, Microservices, and .NET

Let’s understand the business domain with programming, microservices, and .net.

Introduction

In the world of software development, especially in the context of programming, microservices, and .NET, the concept of the business domain plays a vital role in forming the architecture and design of applications.

Let’s explore the business domain, its significance, and how it fits into different architectural paradigms.

What is the Business Domain?

The software application can be designed and developed for a specific area or industry representing the business domain.

Moreover, the business domain encapsulates the rules, processes, and logic defining a business’s operations.

Examples are customer interactions, order processing, inventory management, and financial transactions.

In programming, understanding the business domain is essential for creating software that accurately models and supports a business’s real-world processes and requirements.

It involves collaborating closely with domain experts, typically individuals who deeply understand the business, processes, and complexities.

Within the context of microservices, these small collections of services are modeled around a business domain within microservices.

Business Domain

Business Domain in Microservices Architecture

Having a collection of loosely coupled, independently deployable microservices helps organization structure their application within their network and helps them to communicate.

As a result, they are a form of distributed system.

Each microservice is responsible for a well-defined set of functionalities within the business domain.

For example, in an e-commerce application, you might have microservices for handling product catalogs, order processing, payment, and user authentication.

This type of architecture allows teams to work on different system parts independently, focusing on their specific business domain expertise.

Business Domain in .NET Programming

In the .NET ecosystem, Developers portray the business domain inside an application’s business logic, which includes the rules and workflows that define how data is processed and manipulated to meet business requirements.

In a traditional three-tier architecture, the business layer is where this logic resides. The business layer in a three-tier application separates the presentation layer (user interface) from the data access layer (database interactions).

It is responsible for processing and applying business rules to the data received from the presentation layer before passing it to the data access layer for storage or retrieval.

Clean Architecture and the Business Domain

Clean Architecture is an architectural style that promotes the separation of concerns and the independence of the business logic from external problems like databases and frameworks.

In Clean Architecture, the business domain is at the system’s core, surrounded by layers representing different concerns.

Entities and Use Cases

In the innermost layer of Clean Architecture, you find entities representing the core business objects and use cases describing the application-specific workflows. This is where the actual business logic resides.

Interface Adapters

Moving outward, you have interface adapters that convert data between the external world (user interfaces or external services) and the business logic. These adapters translate the details of the external world into a format that the business logic can understand and vice versa.

Frameworks and Drivers

The outermost layer deals with frameworks and tools like databases, web frameworks, and external services. Clean Architecture should separate these concerns from the business domain to ensure flexibility and maintainability.

Clarifying the Concepts

Business Layer in Three-Tier Architecture

The business layer in a three-tier application is where the business logic is traditionally placed.

It handles the processing of data before it is persisted or retrieved.

Business Domain in Microservices

Each microservice represents a specific business capability or domain in a microservices architecture.

The business domain is distributed across these microservices, allowing for better scalability and maintainability.

Clean Architecture Equivalent

In Clean Architecture, the business domain is represented by the innermost layer, consisting of entities and use cases.

This is where the core business logic resides, independent of external concerns.

Summary

Understanding the business domain is critical in designing effective software solutions.

Whether you are working with microservices, traditional three-tier architectures, or Clean Architecture, keeping the business domain at the forefront ensures that your software aligns with the real-world requirements of the business it serves.

References

Here are some things I have read and watched to produce this content. Please watch and read them, too. Thanks.

This information or code or software is provided for informational purposes only. It should not be considered as professional coding or legal advice. Not all code or information provided may be accurate or suitable for your specific project. Consult a software development expert or legal professional before making any significant coding or legal decisions.

Exploring the Distinction Between Latency and Throughput in Computing

Jin Vincent Necesario — Mon, 20 Nov 2023 12:22:51 +0000

Let’s see the difference between latency and throughput.

Photo by Denny Müller on Unsplash

Introduction

In computing and network performance, two critical concepts often come into play: latency and throughput.

While both are essential metrics that impact the user experience, they represent distinct aspects of a system’s performance.

But before we start exploring that difference, I want to share that I was confused about these terminologies and their differences. But today, I’m happy to say I’m enlightened. I’m sharing my thoughts about these two latency and throughput.

This article will explore the differences between latency and throughput, exploring their definitions, significance, and real-world examples.

Understanding Latency: The Time Factor

It measures the time delay between the initiation of a process and the occurrence of its first noticeable effect.

In web browsing, latency could be the time it takes for a click on a link to display the corresponding webpage. Another example is in the context of computing and networks.

Latency is the time data travels from a source to a destination.

Of course, we can’t ignore some delays. These factors, such as physical distance between devices, processing delays, and network congestion, can influence this time delay differently.

Latency Measurement

Latency is measured in units of time, such as milliseconds ( ms ), microseconds ( µs ), or seconds ( s ).

Most organizations see that latency plays a crucial role in determining the responsiveness of a system.

Let’s try to see the difference between low and high latency.

Low latency is desirable when real-time interactions are essential, such as online gaming, video conferencing, or financial transactions.

High latency can lead to lag, disrupting the real-time nature of the game and negatively impacting user satisfaction. Imagine this scenario: most of them are unsatisfied users.

Consider the example of online gaming, where low latency is vital for a gaming experience. In this context, latency encompasses the time a player’s action (such as pressing a button) takes to be reflected on the screen.

Throughput: The Measure of Capacity

It measures the amount of data that can be transferred from one point to another in time. Unlike latency, which focuses on the time delay of a single operation, throughput provides an overview of a system’s overall data transfer capacity.

Throughput Measurement

You probably know this already, but it is measured in bits per second. That’s right, BPS such as kilobits per second (Kbps), megabits per second (Mbps), or gigabits per second (Gbps).

It reflects the efficiency of a system in terms of data transmission. High throughput is desirable for large data transfer scenarios, such as streaming high-definition videos, file downloads, or cloud data backups.

Consider a scenario where a user downloads a large file from a remote server. In this case, throughput is crucial because it determines how quickly the file can be transferred to the user’s device. A higher throughput allows for faster downloads, enhancing the user experience.

Real-world Examples of Latency and Throughput

Let’s explore a few real-world examples to illustrate the difference between latency and throughput further.

Video Conferencing: Balancing Latency and Throughput

In video conferencing, achieving a balance between latency and throughput is essential.

Low latency ensures that participants observe real-time reactions and responses, creating a natural and engaging conversation.

Simultaneously, sufficient throughput is necessary to transmit high-quality video and audio streams without buffering or interruptions.

Web Browsing: Emphasizing Low Latency

When you click on a link while browsing the internet, the time it takes for the corresponding webpage to load is influenced by latency.

Low latency ensures a prompt response, making the web browsing experience more fluid and responsive.

Throughput comes into play when downloading images, videos, or other content from the webpage, impacting the overall loading time.

Online Gaming: Prioritizing Low Latency

As mentioned earlier, online gaming relies heavily on low latency.

Gamers need instantaneous feedback for their actions to maintain the immersive and competitive nature of the game.

Throughput becomes important when updating game asset patches or communicating with server-side components.

Summary

Latency and throughput are distinct concepts; they are interconnected, and both play vital roles in determining the performance of a system.

The right balance between low latency and high throughput is often the key to delivering a seamless and responsive user experience.

Whether streaming videos, participating in a video conference, or engaging in online gaming, understanding the difference between latency and throughput can empower you to make informed decisions about your technology and services.

As technology advances, optimizing latency and throughput will remain essential for meeting the ever-growing demands of modern computing.

This information or code or software is provided for informational purposes only. It should not be considered as professional coding or legal advice. Not all code or information provided may be accurate or suitable for your specific project. Consult a software development expert or legal professional before making any significant coding or legal decisions.