The question was a simple antonym:

"What is the opposite of prince?" Right answer? "Princess"

My answer? "Peasant"

I was shocked and puzzled. I thought, "Isn't a peasant the opposite of a prince? A prince is a noble, while a peasant is a commoner. They are on opposite ends of the social hierarchy."

That moment stuck with me. It showed me that people can interpret the same question in different ways, and that a "correct" answer is not always the only valid one. It also made me reflect on how I learn and how I approach problems.

Learning styles​

If you answered "Princess," you might be a Symmetry learner. If you answered "Peasant," you might be a Hierarchy learner.

How this applies to learning programming​

When learning programming, a Symmetry learner might focus on the overall structure and patterns of code, while a Hierarchy learner might focus on details and how components interact.

For example, a Symmetry learner might quickly grasp the concept of functions and reuse, while a Hierarchy learner might take longer to learn the syntax but build a stronger mental model of how functions call each other.

Strengths and weaknesses​

Symmetry learners often excel at quickly understanding new languages and frameworks because they spot patterns. However, they might struggle with debugging and complex codebases because they can miss "outside the box" details.

Hierarchy learners often excel at debugging and understanding complex codebases because they track interactions carefully. However, they might struggle to ramp up quickly on a new language because they can get caught in the details.

In Other words​

1. The "Princess" Responder: The Pattern Seeker This person prioritizes Symmetry and Association.

Thinking Style: Intuitive & Relational. They look for the "Matching Pair." In their mind, words exist in sets (Salt/Pepper, Left/Right).

Learning Style: They learn best through Analogies (just like we’ve been doing!). They want to know how a new concept fits into an existing "pair" or "family."

In Coding: This person will write very clean, predictable code. They will name their functions beautifully (like Open/Close) because their brain craves that symmetrical balance.

2. The "Peasant" Responder: The Systems Shaker This person prioritizes Context and Power Dynamics.

Thinking Style: Critical & Structural. They don’t just look at the word; they look at the world the word lives in. They see the hierarchy (High vs. Low) rather than just the gender (Male vs. Female).

Learning Style: They learn best through First Principles. They want to break the system down. They aren't satisfied with a simple "pair"; they want to know the "Why" behind the status of the Prince.

In Coding: This person is great at Architecture and Security. They are the ones who ask, "What happens if the system fails?" or "Who has permission to access this data?" They think about the "levels" of the software.

First Principles in Go​

Why is it the "Opposite" of Analogy? Analogy says: "This is like that." (It's a shortcut).

First Principles says: "I don't care what that is like. What is this, actually?" (It's a deep dive).

Final thoughts​

I still remember losing a point for answering "Peasant" and wondering for a long time why it was not accepted.

Not anymore.

Which one are you? Do you see yourself more as a "Princess" or a "Peasant" learner?

Rule 4: Dependencies point inward, not sideways High-level packages depend on lower-level ones, never the other way around.

• api can depend on store
• store can depend on model
• model depends on nothing

Rule 5: Data shapes travel, behavior stays close to the data

Structs can move across layers, but logic should live where it naturally belongs.

Rule 6: Make illegal states unrepresentable Design types so invalid situations can’t exist in the first place.

Examples:

Use type Slug string instead of string

Use nil pointers to represent absence intentionally

Prefer time.Time over strings

Avoid maps where a struct would express meaning

This rule dramatically reduces defensive code and clarifying questions later.

In Go, types are your first line of validation, not runtime checks.

Rule 1: Packages define ownership (and thus responsibility) for code. If code doesn’t need HTTP, it doesn’t belong in an API handler.

In otherwords, Handlers should not decide where data comes from. The application bootstrap (main.go) decides. Practical example:

• internal/store owns product logic
• internal/api/store owns HTTP concerns
• main / router only wires things together

Rule 2: Models can have behaviors (methods)

• Methods let data complete itself
• Major Benefit: This keeps handlers thin and readable (yah!)

Rule 3: If a method mutates state, use a pointer receiver.

func (p *Product) WithImage() { ... }

Product → copy

*Product → original object

Let's cover other rules in the next time!​

Did you know that you can make a call directly from SharePoint Online? You can use a buttonm or a link to trigger a call to a phone number that is not limited to just MS Teams.

https://teams.microsoft.com/l/call/0/0?users=<user1>,4:<phonenumber>

Buttom replacement to expand color palette

The default color palette in SharePoint Online is limited because it follows the selected theme. It can be frustrating when you want to use a specific color that is not available in the palette. However, you can use a hack to expand the color palette by using a button replacement. You can create a button replacement without developing a separate solution in SPF that opens a color picker and allows you to select any color you want.

Method:

• Use text web part. Use highlighter to select the text and choose the color you want. Then, use the hyperlink option to link the text to the page you want. This way, you can have a wider range of colors to choose from and make your SharePoint Online site more visually appealing.

Reusable web parts

Not all web parts are created equal. Some web parts are more flexible and reusable than others. Here are my top three reusable web parts in SharePoint Online:

1. Adaptive Card Web Part: This web part allows you to create and display adaptive cards, which are a type of card-based UI that can be used to display information and actions in a visually appealing way. You can reuse the same adaptive card across different pages and sites, making it a great option for displaying consistent information.

2. PnP Modern Search Web Part: This web part allows you to create custom search experiences in SharePoint Online. You can reuse the same search configuration across different pages and sites, making it a great option for providing a consistent search experience.

3. To continue...

Their official guidance focus on the following areas of governance:

1. Environment Strategy.
2. Risk Management (data control, security, compliance).
3. Life cycle Management of the solutions.

Reference

How does real world companies implement these governance best practices?​

It depnds on how technology-savy the audience of the organization is. Typically, it is divided into two categories:

1. High-Tech Audience:
2. Non-Technical Audience:

Typically Problems Faced in PowerPlatform Governance in all organizations​

1. Lack of proper documentation and training for users.
2. Over-flowing number of environments created without proper strategy.
3. Difficulty in managing data security and compliance across multiple environments.
4. Challenges in maintaining and updating solutions across different environments.
5. Default environment misuse for production workloads.
6. Transfer of ownership when employees leave the organization.

Next Topic to cover​

Let's discuss the product design behind multiple environments (incluing the default environment) in PowerPlatform. Is this correctly designed? What are the pros and cons of having a default environment? And any assumptions that took into place when designing this architecture?

Architecture Overview​

Docusaurus is built on React, which means you can leverage the power of React components to create dynamic and interactive user interfaces. On the backend, Docusaurus can be integrated with various APIs and services to fetch and display data in real-time.

Docusaurus + Go API Architecture (Folder-Style View)​

User (Browser)
│
└── Docusaurus (React)
└── fetch() → Go API
├── main.go # App entry
├── routes.go # HTTP routes
├── handlers/ # API endpoints
└── middleware/
└── cors.go # Browser access rules

Why cors.go shows up here and not mod.go?​

Frontend does not care about go.mod Browser does not care about go.mod API clients do not care about go.mod

mod.go is just an internal build metadata file for Go projects. It helps manage dependencies and versions but has no role in the runtime behavior of the application. Therefore, it doesn't belong in the integration architecture diagram.

CORS Configuration​

By default, ACA does not enable CORS (Cross-Origin Resource Sharing), which is essential for your Docusaurus frontend to communicate with the Go API backend hosted on ACA. To enable CORS, you need to modify your Go API code to include the appropriate headers. Here 's a simple example of how to set CORS headers in your Go API:

import (
    "net/http"
)
func setCORSHeaders(w http.ResponseWriter) {
    w.Header().Set("Access-Control-Allow-Origin", "*") // Adjust as needed for security
    w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
}

Make sure to call setCORSHeaders in your API handlers to ensure that the headers are included in the responses.

Environment Variables​

When configuring your Docusaurus site to interact with the Go API on ACA, you need to set the correct base URL for the API. In development, you might use a local URL, but in production, you should point to the ACA endpoint. To manage this, you can use environment variables in Docusaurus. For example, you can set DOCUSAURUS_GO_API_BASE_URL in your .env.development.local file for local development and in your production environment settings for the ACA URL.

# .env.development.local
DOCUSAURUS_GO_API_BASE_URL=http://localhost:8080

# Production environment variable
DOCUSAURUS_GO_API_BASE_URL=https://your-container-app.azurecontainerapps.io

Fetching Data in Docusaurus​

When fetching data from the API in your Docusaurus components, make sure to use the environment variable to construct the API URL. Here’s an example of how to do this:

const apiUrl = process.env.DOCUSAURUS_GO_API_BASE_URL
    ? `${process.env.DOCUSAURUS_GO_API_BASE_URL}/api/your-endpoint`
    : '/api/your-endpoint'; // Fallback for development
fetch(apiUrl)

    .then(response => response.json())
    .then(data => {
        // Handle the data
    });

By following these steps, you can successfully configure your Docusaurus site to work with an API hosted on Azure Container Apps, ensuring smooth communication between the frontend and backend.

Formal documentation from Docusaurus​

https://docusaurus.io/docs/deployment

How to handle your Backend API URL:​

Since a Docusaurus site is statically rendered, it cannot access server-side environment variables directly at runtime like a standard Node.js app. Instead, you should pass your backend URL using customFields in your docusaurus.config.js:

Don’t just default to Owner or Contributor access​

The trick to least privilege is splitting access into three specific roles:

AcrPush: Give this to your CI/CD (GitHub/DevOps) to upload the image.

AcrPull: Give this to the Container App’s Managed Identity so it can fetch the image.

Container Apps Contributor: For the deployment command itself. The takeaway: Enable Managed Identity on your app. It’s the easiest way to solve the "Image Pull" error without using insecure admin passwords.

Ditching Legacy Lag: Why Go is My API Cheat Code​

We’ve all been there: staring at a legacy API that crashes under the slightest load, making scaling feel like fitting an elephant through a doorway. A few months ago, that was my life—until I switched to Go.

Honestly? It felt like finding a cheat code for backend development.

Why Go Hits Different​

Go is intentionally simple. While other languages get bogged down in abstractions, Go’s standard library (especially net/http) gives you everything you need for a production-ready REST API right out of the box. No bloated frameworks required.

But the real magic is concurrency. Go’s "goroutines" are so lightweight you can spin up thousands at once. When we migrated a microservice from Node.js to Go.

The Bottom Line​

Deployment is a breeze because Go compiles into a single binary. No dependency nightmares, no "works on my machine" excuses—just build and ship.

If you’re tired of fighting your language and want to start solving actual business problems, Go is the move. It’s fast, the learning curve is gentle, and it won't crumble when real-world traffic hits.

Why Go for APIs?​

I’ve been exploring different programming languages to build a robust, future-proof API—essentially a master API service designed to stand the test of time.

Go quickly stood out as one of the top choices for backend development, especially for building efficient and scalable APIs. I’ve just embarked on the journey of learning Go, and I’m excited to dive deeper into its capabilities.

Here are some reasons why you might choose Drupal:

• Flexibility: Drupal offers a high degree of customization, allowing developers to create complex websites with unique features.
• Scalability: It can handle large amounts of content and traffic, making it suitable for both small websites and large enterprise applications.
• Community Support: Drupal has a large and active community that contributes modules, themes, and provides support.
• Security: Drupal is known for its robust security features and regular updates to address vulnerabilities.

Get Started with Drupal

Explorer a good alternative choice to Microsoft, vendor neutral CMS solution.

Prerequisite​

• PHP
• Composer
• Web Server: Apache, Nginx, or IIS
• Database: MySQL, MariaDB, or PostgreSQL

Recommended Stack to use​

You can use the following pre-packaged solutions

• XAMPP or MAMP (Apache, MySQL, PHP)
• LAMP (Linux)

Steps to get started with Drupal​

1. Download and install Drupal. From your target project folder, run the following in terminal: composer composer create-project drupal/recommended-project drupal What will it do? It will create a project folder name "recommended-project" and all put the dependencies in the folder.

2. Set up a database

sql
CREATE DATABASE drupal_db;
CREATE USER 'drupal_user'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON drupal_db.* TO 'drupal_user'@'localhost';
FLUSH PRIVILEGES;

3. Configure and install drupal by opening your web browser and navigate to http://localhost:my_site_name_dir

It is one of the fastest ways to create API for consumption, in JS.

that provides a robust set of features for web and mobile applications. It is designed for building web applications and APIs, making it easier to manage server-side logic, routing, and middleware.

Prerequisite​

• node js
• npm
• Language: JavaScript

Steps​

1. From your target project folder, run the following in terminal: npx express-generator --no-view

2. Install dependencies by running npm install

3. Create a new file items.js so definition can be described:

       var express = require('express');
       var router = express.Router();
   
       // Sample data
       var items = [
       { id: 1, name: 'Item 1' },
       { id: 2, name: 'Item 2' }
       ];
   
       // Get all items
       router.get('/', function(req, res, next) {
       res.json(items);
       });
   
       // Get a single item by id
       router.get('/:id', function(req, res, next) {
       const item = items.find(i => i.id === parseInt(req.params.id));
       if (!item) return res.status(404).send('Item not found');
       res.json(item);
       });
   
       // Create a new item
       router.post('/', function(req, res, next) {
       const newItem = {
           id: items.length + 1,
           name: req.body.name
       };
       items.push(newItem);
       res.status(201).json(newItem);
       });
   
       module.exports = router;
   

4. Register the items.js file app.js

       var express = require('express');
       var path = require('path');
       var cookieParser = require('cookie-parser');
       var logger = require('morgan');
   
       var indexRouter = require('./routes/index');
       var usersRouter = require('./routes/users');
       var itemsRouter = require('./routes/items'); // Add this line
   
       var app = express();
   
       app.use(logger('dev'));
       app.use(express.json());
       app.use(express.urlencoded({ extended: false }));
       app.use(cookieParser());
       app.use(express.static(path.join(__dirname, 'public')));
   
       app.use('/', indexRouter);
       app.use('/users', usersRouter);
       app.use('/items', itemsRouter); // Add this line
   
       module.exports = app;
   
   

5. Start the server by typing npm start and test in browser by visiting http://localhost:3000/items.

   Confirm by navigating to the site

why people are drawn to the Mkdocs? Because it requires only md language to make edits and it can be used off internet, and many more beautiful feature that comes with the Mkdocs.

Quick Overview where does Mkdocs fit in?​

Here's a quick overview of where MkDocs fits in the broader ecosystem of tools used.

CRM (System of Record) ├─ Dynamics 365 ├─ Salesforce └─ HubSpot

CMS / Docs / Knowledge (System of Knowledge)/Static Site Generators ├─ MkDocs ├─ Docusaurus ├─ GitBook └─ Confluence ├─ Hugo └─ Gatsby

Quick Start

Deploy mkdocs-material to Azure

Easiest tool to build documentation site!

Prerequisites:

• Completed mkdocs project ready for deployment
• An Azure account with an active subscription
• A Github account

Deployment

Fastest way:

1. Go to portal.azure.com

2. Search "Static Web Apps" at the search bar

3. Create a new Statatic Web Apps with the following critical information:

   • Source: GitHub
   • Repository: Select your source code repository from GitHub
   • Branch: pick Main (for now)
   • Build Presets: HTML
   • App Location: "/site/"
   • output Location: "/"

4. Click "Review + create" button. Then click "Create".

5. Wait for the deployment to complete. It may take ~ 10 minutes.

6. To view your web site, click "Go to resource", then click "Visit your site".

!!! note

Don't see the site? Check back later as it may not immediately deploy the site on internet.

How to Update the MKDOCS?​

Once the github recognize the main branch, then it will automatically run the steps to automaticlaly host to the web.

Simply, run mkdocs build. Then publish that version in git.

My verdict​

Intially, I love mkdocs for its simplicity and ease of use. A couple months later, I revisit the docusaurus then I felt it fits better for my use case.

• The front end is more flexible and customizable with React.
• Its folder structure is more intuitive and easier to navigate.