DEV Community: Balaji Sasikumar

Autostart Minikube on Ubuntu

Balaji Sasikumar — Wed, 05 Nov 2025 05:50:17 +0000

So You Want Minikube on Autopilot?

Picture this: the system reboots and—bam!—Minikube is already there, ready to go. No coffee required, no minikube start ritual in the morning. Pure bliss. But Linux needs to know: under whose authority shall this magic commence?

Step 1: Unmask Your Secret Identity

Let’s get personal. Who are you? The all-powerful root, the humble johnny, or the mysterious testsms? To find out, type:

whoami

If your reply is root, you’re basically a wizard. If it’s something else, that’s your user.

Now for your gang affiliation (primary group):

id -gn

Most of the time, your user and group are identical—a bit like Clark Kent and Superman. Remember them! You’ll need both for the systemd spell.

Step 2: Write Your Systemd Spellbook

Open /etc/systemd/system/minikube.service, like so:

sudo nano /etc/systemd/system/minikube.service

Type this incantation (replace test with your actual self—yes, you):

[Unit]
Description=Kickoff Minikube Cluster
After=docker.service

[Service]
Type=oneshot
ExecStart=/usr/local/bin/minikube start
RemainAfterExit=true
ExecStop=/usr/local/bin/minikube stop
StandardOutput=journal
User=test
Group=test

[Install]
WantedBy=multi-user.target

This script orders Minikube to start and stop as you (so it doesn’t go rogue and start the Kubernetes world domination from your grandma’s account).

Step 3: Make systemd Notice You

Like poking a sleepy cat, do this to wake up systemd to your new magical file:

sudo systemctl daemon-reload

No, it doesn’t reboot the system. It just reads your new scribblings and mutters “OK, fine.”

Step 4: Flip the Startup Switch

Tell Linux to run Minikube every time it wakes up:

sudo systemctl enable minikube

If you don’t want to wait for your next power nap, you can start it right now:

sudo systemctl start minikube

Step 5: Confirm Your Spell’s Success

Don’t trust magic blindly—check if Minikube is alive:

sudo systemctl status minikube

If you see active (running), congratulations! If you see inactive (dead), it's time to check logs...or sacrifice a rubber duck.

Summary:

Discover your mysterious username and group, write your service file, reload its magic, and enable it! Welcome to hands-free Minikube on Ubuntu. Enjoy your extra five minutes of sleep—Kubernetes is already up and brewing as soon as your computer starts

Authentication Cheatsheet

Balaji Sasikumar — Thu, 06 Feb 2025 04:29:22 +0000

1. OpenID Connect (OIDC)

An identity layer built on top of OAuth 2.0.
Provides authentication and basic profile information.
Relies on ID tokens (JWT format).

2. Single Sign-On (SSO)

A user logs in once to access multiple applications.
Centralized authentication handled by an Identity Provider (IdP).
Examples: Google SSO, Microsoft Azure AD.

3. OAuth 2.0

An authorization framework (not for authentication).
Grants access to resources without sharing user credentials.
Uses access tokens to secure API calls.

4. Auth0

A cloud-based Identity as a Service (IDaaS) platform.
Supports OAuth 2.0, OIDC, and SAML.
Provides features like user management, MFA, and social login.

5. Identity Providers (IdP)

Services that manage user identity.
Examples: Keycloak, Okta, Azure AD, Ping Identity.

6. SAML (Security Assertion Markup Language)

XML-based protocol for exchanging authentication data.
Often used in enterprise SSO solutions.

7. JWT (JSON Web Token)

A compact, URL-safe token format.
Contains claims (identity, permissions) encoded in three parts: header, payload, signature.

OAuth 2.0 Flows

Flow	Use Case	Steps	Key Token
Authorization Code	User-based web app authentication (most secure).	1. Redirect user to authorize. 2. Exchange authorization code for tokens.	Access, Refresh, ID
PKCE (Proof Key for Code Exchange)	Secure mobile/SPA variant of Authorization Code.	1. Generate a code verifier & challenge. 2. Send verifier in token exchange.	Access, Refresh, ID
Implicit	SPAs needing quick tokens (legacy, less secure).	1. Directly return tokens in the URL fragment after user consent.	Access, ID
Client Credentials	Machine-to-machine communication (no user interaction).	1. Application sends client ID & secret directly.	Access
Resource Owner Password	Direct user credentials exchange (legacy, avoid).	1. Application sends user credentials to the authorization server to get tokens.	Access, Refresh
Device Code	Devices without browsers (e.g., TVs, IoT).	1. Show user a code & URL. 2. User authorizes on another device.	Access, Refresh

OIDC Flows

OIDC builds on OAuth 2.0 by adding ID tokens for authentication.

Flow	Additional Steps for OIDC
Authorization Code	ID token is included in the response to identify the user.
Implicit	Returns both Access & ID tokens directly.
Hybrid	Returns both Authorization Code & ID token in the first response.

Key Tokens

Token	Purpose	Format	Expiry
Access	Authorize API access.	JWT (OAuth 2.0 spec compliant)	Short-lived (minutes).
ID	User authentication & profile claims (OIDC).	JWT	Short-lived (minutes).
Refresh	Obtain new access tokens without re-authenticating.	Opaque or JWT	Long-lived (days/months).

Key Concepts Cheat Sheet

Concept	Description
Redirect URI	Callback URL where tokens/codes are sent after user authorization.
Scopes	Permissions requested by the client application (e.g., `profile`, `email`).
Consent Screen	UI presented to users to approve access scopes requested by the app.
PKCE	Adds a layer of security to prevent interception of authorization codes.
Well-Known URL	Discovery endpoint (`/.well-known/openid-configuration`) for fetching IdP metadata.
MFA	Multi-factor authentication for added security (e.g., SMS, authenticator apps).

Quick Decision Guide

Scenario	Flow to Use
Secure user authentication (web app)	Authorization Code + PKCE
SPA with no backend	PKCE (replaces Implicit flow)
Machine-to-machine API access	Client Credentials
Devices without browsers	Device Code
Avoid (legacy, insecure, or risky scenarios)	Implicit, Resource Owner Password

Comparison of Access Control Models

Feature	Context-Based Access Control (CBAC)	Role-Based Access Control (RBAC)	Fine-Grained Access Control (FGAC)	Discretionary Access Control (DAC)	Mandatory Access Control (MAC)
Decision Basis	Real-time contextual attributes like time, location, device, and user behavior.	Predefined roles and associated permissions.	Highly detailed policies based on specific attributes.	Owner or creator defines access permissions.	Central authority enforces access based on labels.
Flexibility	Highly flexible and adapts to environmental changes.	Limited to static or hierarchical roles.	Extremely flexible; designed for complex needs.	Flexible but depends on owner decisions.	Rigid and predefined, based on strict rules.
Granularity	Medium to High: Uses multiple contextual factors.	Medium: Permissions tied to roles, not specific attributes.	Very High: Can specify access at a granular level.	Low to Medium: Based on owner's definition.	High: Broad classification levels control access.
Adaptability	High: Evaluates access dynamically based on real-time context.	Low: Static, predefined roles rarely change dynamically.	High: Highly customizable for complex needs.	Medium: Relies on owner's decisions.	Low: Cannot adapt dynamically.
Security	Very High: Mitigates risks with dynamic evaluation.	Medium: Static roles can lead to privilege creep.	Very High: Fine-grained policies reduce over-permissioning.	Medium: Risks due to inconsistent permissions.	Very High: Strict rules prevent unauthorized access.
Ease of Implementation	Medium: Requires infrastructure for monitoring context.	Easy: Widely supported and simple to implement.	Complex: Requires detailed policy definitions.	Easy: Straightforward implementation.	Difficult: Strict classification and enforcement.
Scalability	High: Scales well in dynamic environments.	High: Scales well with role hierarchies.	High: Suitable for large systems with diverse requirements.	Low: Limited to individual owners.	Low: Difficult to scale due to rigid structure.
Use Cases	- Remote work environments.	- Enterprise applications.	- Multi-tenant systems.	- Small teams or personal systems.	- Military and government systems.
	- Banking transactions.	- Basic organizational hierarchies.	- Healthcare and finance.	- File-sharing applications.	- Classified data protection.
	- Zero Trust security models.	- Traditional IT.	- GDPR-compliant systems.

Which Model to Use?

Scenario	Recommended Model
Flexible, real-time access control needed	CBAC
Structured, role-based organizations	RBAC
High compliance and precision requirements	FGAC
Small-scale or personal systems	DAC
Military or highly sensitive environments	MAC

APIs: How to Stop Torturing Developers and Start Writing Code They Won't Hate

Balaji Sasikumar — Mon, 30 Dec 2024 17:39:48 +0000

Introduction

Ah, APIs—the love letters developers write to each other (sometimes in a cryptic language no one can understand). Whether you're crafting an elegant symphony of methods or unleashing a monstrosity of unreadable spaghetti code, this guide will help you design APIs that won't make your colleagues cry (or, at least, cry less). Let’s dive in!

Characteristics of Good APIs

1. Easy to Learn and Memorize

A good API should be so simple even your grandma could use it. If your API feels like it requires a PhD in rocket science, you’re doing it wrong. Let's say you're building a calculator API.

Bad API Example:

calculate(1, "plus", 2, { round: false, mode: "basic", verbosity: "low" });

"Uh, what? Why do I need to know the verbosity of a basic addition?"

Good API Example:

calculator.add(1, 2); // Ah, so simple even my pet goldfish gets it!

2. Leads to Readable Code

Readable APIs are the ones you can skim through without questioning your life choices.

Sarcastic Scenario: Imagine you’re debugging at 2 AM with coffee in one hand and despair in the other. Which code would you prefer?

Bad API Example:

const res = x.A(1, 2).B(3).C();  
// What is A? What is B? Are we building a spaceship or solving math?

Good API Example:

const result = calculator.add(1, 2).multiply(3).getResult();  
// Ah, now I know what I’m doing. I'm multiplying happiness.

3. Hard to Misuse

An API that’s easy to misuse is like a vending machine that eats your money. Let’s protect developers from themselves.

Bad API Example:

calculator.add("apple", "banana"); // Hmm, should this work? It does. But why?

Good API Example:

calculator.add(1, 2); // Only numbers allowed, sorry fruit enthusiasts.

And, of course, throw an error that screams:

"Invalid argument type: We accept numbers, not your grocery list!"

The Design Process

4. Know the Requirements

Before you write any code, ask yourself:

What do users need?
What do they actually need (not what they say they need)?

Example: If users need a Todo API, don’t build a rocket launcher API. Stay focused.

5. Write Use Cases First

Ever tried assembling IKEA furniture without instructions? Writing code without use cases is kind of like that, but worse.

Use Case:

// BEFORE implementation:
todo.addTask("Write blog").completeTask(1).deleteTask(1);

Now, build the API to match this. No extra fluff, no over-engineering.

6. Prepare for Extensions

Don’t create a rigid API that breaks the moment someone wants to add a feature.

Example of Extensible API:

interface Calculator {
  add(a: number, b: number): Calculator;
  subtract(a: number, b: number): Calculator;
  withOptions(options: { precision?: number; mode?: "basic" | "scientific" }): Calculator;
}

7. When in Doubt, Leave It Out

Developers love adding features like it’s a toppings bar. But sometimes, the best topping is nothing.

Sarcastic Example:

// Bad API with unnecessary features:
todo.addTask("Cook dinner", { priority: "urgent", notifyVia: "pigeon", withEmojis: true });

Really? Emojis and pigeon notifications? Calm down.

Design Guidelines

8. Choose Self-Explanatory Names

Your API should be so clear even a 5-year-old could explain it.

Bad Example:

t.api(1, "xyz"); // What is this sorcery?

Good Example:

todo.addTask("Learn TypeScript").completeTask(1);

See? Clear, concise, and makes you look smart.

9. Avoid Abbreviations

Abbreviations are for Twitter, not APIs.

Bad Example:

usrMgmt.addUsr("John");

Is this a typo or code?

Good Example:

userManagement.addUser("John");

10. The Best API is No API

Sometimes, simplicity means not writing an API at all. Can you solve the problem without it? If yes, do that instead.

Example:

Instead of a custom fetchData API, just use:

fetch("https://example.com/data").then((res) => res.json());

🎨 Mastering Angular-React Integration: How to Use tldraw Without Losing Your Mind!

Balaji Sasikumar — Sun, 01 Dec 2024 12:26:53 +0000

Introduction

If you’re an Angular dev eyeing the React world, you might feel like a cat walking into a dog park. tldraw—the cool kid on the React block—makes it seem worth the risk. But how do you get them to play nicely together? By using web components, the ultimate middleman that lets Angular and React shake hands instead of throwing shade. 🚀

What are Web Components?

Imagine a magical HTML element that doesn’t care who made it—it just works. That’s a web component for you! It's like the Switzerland of the web frameworks, neutral and ready to mediate.

Key Features:

Custom Elements: Make up your own tags like <awesome-button>.
Shadow DOM: Keeps your styles from messing with everyone else’s (no sibling drama here!).
HTML Templates: Build it once, reuse it everywhere (yes, like Legos).

What is r2wc?

Think of r2wc as the translator between React and the rest of the web. It wraps your React components in a cozy custom element that even Angular can understand. 😎

How it Works:

Take your React component. 🧑‍🎨
Wrap it with r2wc. 🛁
Register it as a custom element with a snazzy name like <tl-draw>. 🏷️

Step-by-Step Guide

Step 1: Install the Required Stuff

Get the cool toys with:

npm install @r2wc/react-to-web-component @tldraw/tldraw react react-dom

Step 2: Let Angular Know About Web Components

Add this to your Angular module, so Angular doesn’t freak out about your new custom elements:

import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule],
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  bootstrap: [AppComponent],
})
export class AppModule {}

Step 3: Add tldraw Styles

You can’t draw without style, right? Add tldraw's styles to your Angular app.

Open angular.json and include the following in the styles array:

"styles": [
  "src/global.scss",
  "node_modules/tldraw/tldraw.css"
]

Step 4: Importing tldraw Based on Angular Version

For Angular 15 and Above:

import r2wc from "@r2wc/react-to-web-component";
import { Tldraw, getSnapshot } from "@tldraw/tldraw";

For Angular Below 15:

import r2wc from "../../node_modules/@r2wc/react-to-web-component/dist/react-to-web-component.js";
import { Tldraw, getSnapshot } from "../../node_modules/tldraw/dist-esm/index.mjs";

Because Angular’s TypeScript isn’t quite ready to hang with tldraw. 🙃. This workaround is necessary because tldraw uses TypeScript features that older Angular versions don’t fully support.

Step 5: Create tldraw.js

Create a file named tldraw.js to convert the tldraw React component into a web component.

Here’s the magic potion that converts tldraw into a web component:

import r2wc from "@r2wc/react-to-web-component";
import { Tldraw, getSnapshot } from "@tldraw/tldraw";

const TldrawComponent = r2wc(Tldraw, {
  props: {
    forceMobile: "boolean",
    snapshot: "json",
    onMount: "function",
  },
});

customElements.define("tl-draw", TldrawComponent);

export const getSnapshot1 = getSnapshot;

This wraps the tldraw component and defines it as a custom element named .

Step 6: Use the Web Component in Angular

Here’s how you can use <tl-draw> in your Angular app.

HTML (app.component.html):

<div style="width: 100vw; height: 95vh">
  <button
    (click)="handleSaveChanges()"
    [ngStyle]="{
      position: 'absolute',
      top: '44px',
      right: '0.5em',
      padding: '8px 16px',
      zIndex: 100,
      backgroundColor: hasUnsavedChanges ? '#007bff' : '#ccc',
      cursor: hasUnsavedChanges ? 'pointer' : 'not-allowed',
      opacity: hasUnsavedChanges ? 1 : 0.6
    }"
  >
    Save
  </button>
  <tl-draw
    [forceMobile]="true"
    [snapshot]="snapshot"
    [onMount]="onMountEvent"
  ></tl-draw>
</div>

TypeScript (app.component.ts):

import { Component, OnInit } from '@angular/core';
import { getSnapshot1 } from './path-to-tldraw.js';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss'],
})
export class AppComponent implements OnInit {
  hasUnsavedChanges = false;
  snapshot: any;
  editor: any;

  onMountEvent = (editor: any) => {
    this.editor = editor;
    editor.store.listen(this.handleChangeEvent, { source: 'user', scope: 'all' });
  };

  handleChangeEvent = (change: any) => {
    if (
      Object.keys(change.changes.added).length ||
      Object.keys(change.changes.updated).length ||
      Object.keys(change.changes.removed).length
    ) {
      this.hasUnsavedChanges = true;
    }
  };

  handleSaveChanges = () => {
    const snapshot = getSnapshot1(this.editor.store);
    console.log('Snapshot saved:', snapshot);
    this.hasUnsavedChanges = false;
    localStorage.setItem('drawingSnapshot', JSON.stringify(snapshot));
  };

  ngOnInit() {
    const savedSnapshot = localStorage.getItem('drawingSnapshot');
    this.snapshot = savedSnapshot ? JSON.parse(savedSnapshot) : {};
  }
}

Now, you’re all set to use tldraw in your Angular app! 🎉

Key Takeaways

Props Mapping: React props become Angular-friendly attributes via r2wc. For example:

<tl-draw
    [forceMobile]="true"
    [snapshot]="snapshot"
    [onMount]="onMountEvent"
></tl-draw>

Event Handling: Use Angular bindings to handle events like [onMount]="onMountEvent".
Snapshots FTW: Save and restore drawing state using getSnapshot.

You’ve successfully bridged the React-Angular divide! 🎉

Common Gotchas

TypeScript Compatibility: If you see errors, try downgrading TypeScript to a compatible version.
Missing Styles: If your canvas looks broken, check angular.json to ensure tldraw.css is added to the styles array.
Prop Mismatches: Double-check the props object in tldraw.js to make sure attributes like forceMobile are correctly exposed.

Conclusion

By the time you’re done, your Angular app will be flexing tldraw like it was born to do it. Who said React and Angular can’t get along? With a little help from r2wc, you’ve just made it happen. Go on, give yourself a high five! 🖐️🎉

Inside SQL Joins

Balaji Sasikumar — Wed, 15 May 2024 18:19:17 +0000

SQL joins are fundamental to querying databases, allowing users to combine data from multiple tables based on specified conditions. Joins are categorized into two main types: logical joins and physical joins. Logical joins represent the conceptual way in which data from tables is combined, while physical joins refer to the actual implementation of these joins within database systems like RDS (Relational Database Service) or other SQL servers. In today's blog post, we'll unravel the mysteries of SQL joins.

Let's jump in!

Logical Join

There are various types of logical joins in SQL. The two most common are Inner join and Outer join. We use these joins when we need to retrieve data from tables.

Physical Join

Physical joins are implemented inside RDS. The user writes the query using a logical join and RDS uses a physical join to perform the join operations. There are different types of physical joins like
1. Nested Loop Join
2. Hash Join
3. Merge Join and so on

Nested Loop Join

This is a type of join where a smaller table with fewer records is selected and looped through the other table until a match is found. This type of join is available in MySQL, Postgres, and even SQL servers. However, it is not a scalable option for large tables. It is mainly used in cases where the join operator does not use equality.

For example,Geospatial Queries: When dealing with geographic data, you might want to find points within a certain distance of other points. This could involve comparing the distance between every combination of points, which could be achieved with a Nested Loop Join.

SELECT *
FROM cities
JOIN landmarks ON distance(cities.location, landmarks.location) < 100;

Hash Join

Hash join is a method of executing a join using the hash table to find a match record. A hash table is created in memory. If there is a large amount of data and there is not enough memory to store it, then it is written to disk. Hash join is more efficient than Nested Loop join. During execution, RDS builds the in-memory hash table where the rows from the join table are stored using the join attribute as the key. After the execution, the server starts reading the rows from the other table and finds the corresponding row from hash table. This method is commonly used when the join operator uses equality.

Suppose you have an "Employee" table with employee details like ID, name, and department ID, and a "Department" table with department details like ID and name. You want to join these tables to get the department each employee belongs to

SELECT *
FROM Employee
JOIN Department ON Employee.department_id = Department.department_id;

In this example the join condition is based on equality between columns, making it suitable for a hash join. This method is efficient, especially when dealing with large datasets, as it can quickly match records using the hash table. However, as with any join method, it's important to consider the size of the datasets and available memory to ensure optimal performance.

Merge Join

Merge Join is a method used in SQL query execution when the join condition employs an equality operator and both sides of the join are large. This technique relies on sorted data inputs. If there exists an index on the expressions used in the join column, it can be utilized to obtain the sorted data efficiently. However, if the server needs to sort the data explicitly, it's crucial to analyze the indexes and consider optimizing them for improved performance.

Example:
Consider a scenario involving a "Sales" table with sales transactions, including sale ID, customer ID, and sale amount, and a "Customers" table containing customer details like customer ID, name, and location.

SELECT *
FROM Sales
JOIN Customers ON Sales.customer_id = Customers.customer_id;

In this case, both the "Sales" and "Customers" tables are substantial, and the join condition relies on the equality of the "customer_id" column. For an efficient merge join, both input tables need to be sorted by the join column ("customer_id"). If there's no existing index on the "customer_id" column, the server may need to perform additional sorting operations, which could impact performance.

To optimize the merge join, it's advisable to create or modify indexes on the "customer_id" column in both tables. Ensuring proper maintenance and optimization of these indexes can lead to significant improvements in query performance, particularly for queries frequently involving joins based on the "customer_id" column.

By leveraging indexes effectively and ensuring sorted data inputs, merge joins can efficiently handle joins between large tables with equality-based join conditions, contributing to enhanced query performance and overall system efficiency.

Aspect	Nested Loop Join	Hash Join	Merge Join
Join Condition	Non-equality	Equality	Equality
Input Data Size	Small to Medium	Medium to Large	Large
Data Sorting	Not required	Not required	Required
Memory Usage	Low	Moderate to High	Moderate to High
Index Utilization	Not a primary concern	Beneficial	Relies on indexes
Performance(large datasets)	Slower	Efficient	Efficient
Scalability	Less scalable	Scalable	Scalable
Typical Use Cases	Small to medium-sized tables	Large tables with equality joins	Large tables with equality joins