DEV Community: Subham Behera

DevSecOps with Github Actions and ArgoCD

Subham Behera — Sat, 26 Jul 2025 08:59:42 +0000

Architecture Overview

Infrastructure: AWS EKS Cluster with managed node groups
CI/CD: GitHub Actions for building and pushing Docker images
GitOps: ArgoCD for continuous deployment
Security: tfsec , trivy and sealed secret.
Tools: Terraform, Helm, kubectl, eksctl

Step 1: Prepare Ubuntu VM

Start with a fresh Ubuntu VM (recommended: Ubuntu 20.04 LTS or later) and ensure you have sudo access.

# Update the system
sudo apt update && sudo apt upgrade -y

Step 2: Install Required Tools

Install Dependencies and AWS CLI

# Install unzip utility
sudo apt install unzip -y

# Install AWS CLI v2
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Verify installation
aws --version

Install eksctl

# Set architecture (change to arm64, armv6, or armv7 for ARM systems)
ARCH=amd64
PLATFORM=$(uname -s)_$ARCH

# Download eksctl
curl -sLO "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_$PLATFORM.tar.gz"

# Optional: Verify checksum
curl -sL "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_checksums.txt" | grep $PLATFORM | sha256sum --check

# Extract and install
tar -xzf eksctl_$PLATFORM.tar.gz -C /tmp && rm eksctl_$PLATFORM.tar.gz
sudo install -m 0755 /tmp/eksctl /usr/local/bin && rm /tmp/eksctl

# Verify installation
eksctl version

Install kubectl

# Install kubectl via snap
sudo snap install kubectl --classic

# Verify installation
kubectl version --client

Install Terraform

# Download and install Terraform
curl -O https://releases.hashicorp.com/terraform/1.5.6/terraform_1.5.6_linux_amd64.zip
unzip terraform_1.5.6_linux_amd64.zip
sudo mv terraform /usr/local/bin/

# Verify installation
terraform -version

Install Helm

# Download and install Helm
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

# Verify installation
helm version

Step 3: Configure AWS Credentials

Configure AWS CLI with your credentials:

aws configure

Provide the following information:

AWS Access Key ID: Your AWS access key
AWS Secret Access Key: Your AWS secret key
Default region name: us-east-1 (or your preferred region)
Default output format: table

Step 4: Create EKS Cluster

Create the EKS Cluster

eksctl create cluster \
  --name react-eks \
  --region us-east-1 \
  --nodegroup-name react-nodes \
  --node-type t3.medium \
  --nodes 2 \
  --nodes-min 1 \
  --nodes-max 3 \
  --managed

Note: This process takes 15-20 minutes. While waiting, proceed with the GitHub repository setup.

Verify Cluster Creation

# Verify cluster is running
kubectl get nodes

# Get cluster info
kubectl cluster-info

Step 5: Setup GitHub Repository

Create Repository Structure

Create a new repository similar to: https://github.com/subham-behera/devops-project

Your repository should include:

devops-project/
├── k8s/
│   ├── deployment.yaml
│   ├── service.yaml
├── terraform/
│   ├── main.tf
│   ├── variables.tf
│   ├── terraform.tfvars
│   └── outputs.tf
├── .github/
│   └── workflows/
│       └── main.yaml
├── Dockerfile
├── package.json
├── nginx.conf
└── src/
    └── (your React app files)

Under terraform directory we just need a simple script to test. So it can even work with main.tf

Configure GitHub Secrets

In your GitHub repository, go to Settings → Secrets and variables → Actions, and add:

DOCKER_USERNAME: Your Docker Hub username
DOCKER_PASSWORD: Your Docker Hub password or access token

We can get the secrets from Docker Hub account.

Sample GitHub Actions Workflow

Create .github/workflows/main.yaml:

Get the file at devops-project/.github/workflows/main.yml at main · subham-behera/devops-project

Step 6: Install Sealed Secrets

Install Sealed Secrets Controller

# Install the Sealed Secrets controller
kubectl apply -f https://github.com/bitnami-labs/sealed-secrets/releases/latest/download/controller.yaml

# Verify installation
kubectl get pods -n kube-system | grep sealed-secrets

Create and Seal Secrets

# Create a regular secret (don't apply this)
kubectl create secret generic my-app-secret \
  --from-literal=REACT_APP_API_KEY=super-secret-value \
  --dry-run=client -o yaml > my-app-secret.yaml

# Install kubeseal (Sealed Secrets CLI)
wget https://github.com/bitnami-labs/sealed-secrets/releases/download/v0.24.0/kubeseal-0.24.0-linux-amd64.tar.gz
tar -xzf kubeseal-0.24.0-linux-amd64.tar.gz
sudo install -m 755 kubeseal /usr/local/bin/kubeseal

# Create sealed secret
kubeseal -f my-app-secret.yaml -w sealed-secret.yaml

# Apply the sealed secret
kubectl apply -f sealed-secret.yaml

Step 7: Install and Configure ArgoCD

Install ArgoCD

# Create ArgoCD namespace
kubectl create namespace argocd

# Install ArgoCD
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Wait till process gets completed.

Get ArgoCD Admin Password

# Get the initial admin password
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 --decode ; echo

Important: Copy this password as you'll need it to log into ArgoCD.

Access ArgoCD UI

# Forward port to access ArgoCD UI
kubectl port-forward svc/argocd-server -n argocd 8080:443 --address=0.0.0.0

Note: Make sure port 8080 is allowed in your security group/firewall.

Access ArgoCD at: https://your-vm-ip:8080

Username: admin
Password: (the password you copied earlier)

Configure Repository Connection

In ArgoCD UI:

Go to Settings → Repositories
Click Connect Repo
Enter your GitHub repository URL
Provide authentication if repository is private

Before moving make sure to make manifest files like deployment.yml and service.yml inside k8s directory.

Create Application

In ArgoCD UI:

Click New App
Fill in the following fields:

- **Application Name**: react-app
- **Project**: default
- **Sync Policy**: Automatic
- **Repository URL**: Your GitHub repository URL
- **Path**: k8s (path to your Kubernetes manifests)
- **Destination Cluster**: https://kubernetes.default.svc
- **Namespace**: default

Click Create

Step 8: Verify Deployment

Check Application Status

# Check pods
kubectl get pods

# Check services
kubectl get svc

# Get external IP (if using LoadBalancer service)
kubectl get svc your-service-name

Access Your Application

If using a LoadBalancer service, get the external IP and access your application.

Step 9: Test the Complete Pipeline

Make a Code Change

Make a simple change to your React application
Commit and push to the main branch
GitHub Actions will automatically:
- Build the Docker image
- Push it to Docker Hub
- Update the Kubernetes manifests
ArgoCD will automatically:
- Detect the changes
- Deploy the updated application

Monitor the Deployment

Check GitHub Actions for build status
Check ArgoCD UI for deployment status
Verify the changes are reflected in your running application

Note : After completion check if you can see and download the artifact in github actions.

Cleanup

To avoid AWS charges, cleanup resources when done:

# Delete EKS cluster
eksctl delete cluster --name react-eks --region us-east-1

# This will delete all associated resources

The Bizarre World of JavaScript Type Coercion

Subham Behera — Sun, 07 Jul 2024 01:50:26 +0000

JavaScript is a versatile and powerful language, but it comes with its own set of quirks. One of the most bizarre and often misunderstood aspects of JavaScript is type coercion. Type coercion is the process by which JavaScript automatically converts a value from one type to another. This can lead to some unexpected and downright weird behaviors.

Understanding Type Coercion

Type coercion in JavaScript can occur in various situations, such as during comparisons, arithmetic operations, and even in logical contexts. JavaScript has two types of equality operators: == (loose equality) and === (strict equality). The loose equality operator (==) performs type coercion, while the strict equality operator (===) does not.

Let's start with some simple examples to see how type coercion works:

console.log(1 == '1'); // true
console.log(1 === '1'); // false

In the first example, JavaScript converts the string '1' to a number before making the comparison, resulting in true. In the second example, no conversion occurs, so the comparison returns false.

Type Coercion in Arithmetic Operations

Type coercion can lead to some unexpected results in arithmetic operations. Let's look at a few examples:

console.log('5' - 3); // 2
console.log('5' + 3); // '53'
console.log('5' * '2'); // 10
console.log('5' / '2'); // 2.5

In the first example, the string '5' is converted to a number before the subtraction operation, resulting in 2. However, in the second example, the + operator concatenates the string '5' and the number 3, resulting in the string '53'. The * and / operators also convert strings to numbers before performing the operations.

The Infamous `NaN` and Type Coercion

NaN stands for "Not-a-Number," but it is, in fact, a number type in JavaScript. Type coercion involving NaN can lead to some peculiar results:

console.log(NaN == NaN); // false
console.log(NaN === NaN); // false
console.log(isNaN(NaN)); // true
console.log(isNaN('hello')); // true

NaN is the only value in JavaScript that is not equal to itself, which is why NaN == NaN and NaN === NaN both return false. The isNaN function can be particularly confusing because it returns true for non-numeric strings as well.

Coercion in Logical Contexts

Type coercion also occurs in logical contexts, such as if statements and logical operators (&&, ||):

console.log(false == '0'); // true
console.log(false === '0'); // false
console.log(null == undefined); // true
console.log(null === undefined); // false

if ('hello') {
  console.log('This is true!'); // This is true!
}

if ('') {
  console.log('This is true!');
} else {
  console.log('This is false!'); // This is false!
}

In logical contexts, JavaScript coerces values to booleans. Non-empty strings are truthy, while empty strings are falsy. Similarly, null and undefined are both falsy, but null == undefined returns true due to type coercion.

The Weirdness of Arrays and Objects

Type coercion can produce some truly bizarre results when dealing with arrays and objects:

console.log([] == ''); // true
console.log([] == 0); // true
console.log([1, 2, 3] == '1,2,3'); // true
console.log({} == '[object Object]'); // false
console.log({} + []); // '[object Object]'
console.log([] + {}); // '[object Object]'

In the first example, an empty array is coerced to an empty string, resulting in true. In the second example, the empty array is coerced to 0, also resulting in true. The third example converts the array [1, 2, 3] to the string '1,2,3'. However, when comparing objects, the results can be less predictable, as seen in the fourth example.

The last two examples demonstrate the odd behavior of the + operator with arrays and objects. When adding an empty array to an object, JavaScript converts both to strings and concatenates them.

Avoiding Type Coercion Pitfalls

To avoid the pitfalls of type coercion, it's important to use the strict equality operator (===) whenever possible. This ensures that no type conversion occurs during comparisons:

console.log(1 === '1'); // false
console.log(false === '0'); // false
console.log(null === undefined); // false

Additionally, you can use explicit type conversion to make your intentions clear:

console.log(Number('5') - 3); // 2
console.log(String(5) + '3'); // '53'
console.log(Boolean('hello')); // true
console.log(Boolean('')); // false

Conclusion

JavaScript type coercion can lead to some surprising and sometimes confusing results. You can avoid many common pitfalls by understanding how type coercion works and using strict equality checks and explicit type conversions. Embrace the quirks of JavaScript, and you'll be better equipped to handle the bizarre world of type coercion with confidence.

Happy coding!

Uncovering Hidden Gems in JavaScript

Subham Behera — Fri, 05 Jul 2024 11:22:45 +0000

JavaScript is one of the most versatile and widely used programming languages in the world. It powers everything from simple websites to complex web applications. While many developers are familiar with its core features, JavaScript also has a plethora of lesser-known, yet incredibly useful, features that can make your code more efficient, elegant, and fun to write. In this blog post, we will explore some of these hidden gems that can take your JavaScript skills to the next level.

1. The `??` Nullish Coalescing Operator

The nullish coalescing operator (??) is a relatively new addition to JavaScript, introduced in ECMAScript 2020. It provides a way to handle null or undefined values without falling back on other falsy values like 0 or an empty string.

Example:

const name = null;
const defaultName = "Guest";

console.log(name ?? defaultName); // Output: Guest

Use Case:

This operator is particularly useful when you want to assign default values to variables that may be null or undefined, but you don't want to override other falsy values.

2. The `?.` Optional Chaining Operator

Optional chaining (?.) allows you to safely access deeply nested properties of an object without having to check each reference manually.

Example:

const user = {
  profile: {
    address: {
      city: "New York"
    }
  }
};

console.log(user.profile?.address?.city); // Output: New York
console.log(user.profile?.contact?.email); // Output: undefined

Use Case:

Optional chaining can save you from writing lengthy and error-prone conditional checks when accessing nested properties.

3. The `!!` Double Bang Operator

The double bang operator (!!) is a quick way to convert a value to its boolean equivalent.

Example:

const isAuthenticated = !!user; // Converts the truthiness of user to a boolean value
console.log(isAuthenticated); // Output: true or false

Use Case:

This operator is handy for ensuring that a value is explicitly converted to true or false in a concise manner.

4. The `?.[]` Optional Chaining with Dynamic Keys

Optional chaining also works with dynamic keys, which can be extremely useful when dealing with objects with dynamic property names.

Example:

const user = {
  settings: {
    theme: "dark"
  }
};

const key = "theme";
console.log(user.settings?.[key]); // Output: dark
console.log(user.settings?.[key]?.background); // Output: undefined

Use Case:

This feature is useful when accessing properties with dynamic keys, ensuring you avoid runtime errors.

5. The `Object.fromEntries()` Method

The Object.fromEntries() method transforms a list of key-value pairs into an object, which is the inverse operation of Object.entries().

Example:

const entries = [
  ['name', 'Alice'],
  ['age', 25]
];

const obj = Object.fromEntries(entries);
console.log(obj); // Output: { name: 'Alice', age: 25 }

Use Case:

This method is great for converting data structures like maps or arrays of pairs into objects.

6. The `import()` Function for Dynamic Imports

The import() function allows you to dynamically load modules, which can be useful for code splitting and lazy loading in modern JavaScript applications.

Example:

import('./module.js')
  .then(module => {
    module.doSomething();
  })
  .catch(err => {
    console.error('Error loading module:', err);
  });

Use Case:

Dynamic imports are perfect for improving performance by loading code only when it's needed.

7. The `Proxy` Object for Meta-Programming

The Proxy object enables you to create a proxy for another object, which can intercept and redefine fundamental operations for that object.

Example:

const target = {
  message: "Hello, world!"
};

const handler = {
  get: (obj, prop) => {
    return prop in obj ? obj[prop] : "Property does not exist";
  }
};

const proxy = new Proxy(target, handler);
console.log(proxy.message); // Output: Hello, world!
console.log(proxy.nonExistentProperty); // Output: Property does not exist

Use Case:

Proxies are powerful for adding custom behavior to objects, such as validation, logging, or modifying property access.

8. The `Reflect` API

The Reflect API provides methods for interceptable JavaScript operations. It's used in conjunction with Proxy to perform default operations.

Example:

const target = {
  message: "Hello, world!"
};

const handler = {
  set: (obj, prop, value) => {
    if (prop === "message" && typeof value !== "string") {
      throw new TypeError("Message must be a string");
    }
    return Reflect.set(obj, prop, value);
  }
};

const proxy = new Proxy(target, handler);
proxy.message = "Hi!"; // Works
proxy.message = 42;    // Throws TypeError: Message must be a string

Use Case:

The Reflect API is useful for default operations in proxy traps, making your code more readable and less error-prone.

9. Tagged Template Literals

Tagged template literals allow you to parse template literals with a function. This can be useful for creating custom string processing functions.

Example:

function highlight(strings, ...values) {
  return strings.reduce((result, string, i) => {
    return `${result}${string}<span class="highlight">${values[i] || ''}</span>`;
  }, '');
}

const name = "JavaScript";
const sentence = highlight`Learning ${name} is fun!`;
console.log(sentence); // Output: Learning <span class="highlight">JavaScript</span> is fun!

Use Case:

Tagged template literals are great for creating custom string formatting and processing functions.

10. The `Intl` Object for Internationalization

The Intl object provides language-sensitive string comparison, number formatting, and date and time formatting.

Example:

const date = new Date(Date.UTC(2020, 11, 20, 3, 0, 0));
const options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };

console.log(new Intl.DateTimeFormat('en-US', options).format(date)); // Output: Sunday, December 20, 2020
console.log(new Intl.DateTimeFormat('de-DE', options).format(date)); // Output: Sonntag, 20. Dezember 2020

Use Case:

The Intl object is invaluable for applications that need to support multiple languages and locales, providing consistent and accurate formatting.

Conclusion

JavaScript is full of hidden features that can make your code more powerful, efficient, and elegant. From the nullish coalescing and optional chaining operators to dynamic imports and the Intl object, these lesser-known features offer a treasure trove of functionality for developers. By incorporating these gems into your coding toolkit, you can write more expressive, maintainable, and efficient JavaScript.

Have you discovered any other hidden features in JavaScript that you find particularly useful? Share your thoughts in the comments below!

The Quirky Side of C++: Weird Stuff That Makes Us Love (and Hate) It

Subham Behera — Fri, 05 Jul 2024 02:51:43 +0000

Welcome, fellow coders, to a whimsical journey through the quirks and oddities of C++. While C++ is celebrated for its power and flexibility, it also comes with a host of peculiarities that can surprise even seasoned developers. Let's dive into some of the weird and wonderful aspects of C++ that make it the charming (and sometimes infuriating) language it is.

1. The Infamous "Most Vexing Parse"

One of the most notorious oddities in C++ is the "most vexing parse," a term coined by Scott Meyers. This quirk can turn what looks like an innocuous declaration into something entirely unexpected.

std::vector<int> v(std::vector<int>::size_type(10), 20);

You might think this creates a vector with 10 elements, each initialized to 20. But no, it actually declares a function named v that returns a std::vector<int> and takes a parameter of type std::vector<int>::size_type and another parameter of type int.

To avoid this, use uniform initialization (a.k.a. brace initialization):

std::vector<int> v{10, 20};

2. Default Arguments in Function Templates

Default arguments in function templates can lead to some baffling behaviour. Consider this example:

template<typename T>
void foo(T t = 10) {
    std::cout << t << std::endl;
}

int main() {
    foo(); // Error: no matching function for call to 'foo()'
}

Even though 10 is a valid default argument for an int, the compiler doesn't know T is int until it's explicitly told. A workaround is to use an overloaded function:

void foo(int t = 10) {
    std::cout << t << std::endl;
}

template<typename T>
void foo(T t) {
    std::cout << t << std::endl;
}

int main() {
    foo(); // Works!
}

3. The Magic of SFINAE

SFINAE (Substitution Failure Is Not An Error) is a cornerstone of C++ template metaprogramming, allowing for complex template logic. However, it can be quite perplexing at first glance.

template<typename T>
auto test(int) -> decltype(std::declval<T>().foo(), std::true_type{});

template<typename T>
std::false_type test(...);

struct HasFoo {
    void foo() {}
};

int main() {
    std::cout << decltype(test<HasFoo>(0))::value << std::endl; // Prints 1 (true)
    std::cout << decltype(test<int>(0))::value << std::endl;    // Prints 0 (false)
}

The SFINAE magic here checks if a type T has a member function foo and sets the return type accordingly. It's a powerful feature, but can lead to head-scratching moments.

4. The Curious Case of `std::vector<bool>`

std::vector<bool> is a special case in the C++ Standard Library. Unlike other std::vector specializations, it doesn't store bool values directly. Instead, it uses a bit-field-like structure to save space, leading to unexpected behaviour.

std::vector<bool> vb = {true, false, true};
vb[0] = false;

std::cout << std::boolalpha << vb[0] << std::endl; // Prints false

The non-standard representation can cause performance issues and surprising side effects. If you need a true std::vector of boolean-like values, consider using std::vector<char> or std::vector<int> instead.

5. The Hidden Cost of Copy Elision

Copy elision is an optimization technique where the compiler omits unnecessary copy and move operations. However, this can lead to some unexpected scenarios.

struct Widget {
    Widget() { std::cout << "Widget()" << std::endl; }
    Widget(const Widget&) { std::cout << "Widget(const Widget&)" << std::endl; }
    Widget(Widget&&) { std::cout << "Widget(Widget&&)" << std::endl; }
};

Widget createWidget() {
    return Widget();
}

int main() {
    Widget w = createWidget();
}

With copy elision, the compiler might optimize away the copy and move constructors, making it seem like they are never called, even though they exist.

6. The Enigma of Name Hiding

Name hiding can cause some truly baffling behaviour. If a derived class declares a member with the same name as one in the base class, it hides all base class members with that name, even if the signatures are different.

struct Base {
    void f(int) { std::cout << "Base::f(int)" << std::endl; }
};

struct Derived : Base {
    void f(double) { std::cout << "Derived::f(double)" << std::endl; }
};

int main() {
    Derived d;
    d.f(10); // Error: no matching function for call to 'Derived::f(int)'
}

To avoid this, bring the base class function into scope using using:

struct Derived : Base {
    using Base::f;
    void f(double) { std::cout << "Derived::f(double)" << std::endl; }
};

int main() {
    Derived d;
    d.f(10); // Prints "Base::f(int)"
    d.f(10.0); // Prints "Derived::f(double)"
}

Conclusion

C++ is a language full of quirks and intricacies that can be both fascinating and frustrating. These weird aspects are part of what makes C++ so powerful and versatile, yet they also highlight the importance of understanding the language deeply. Embrace the quirks, and you'll find C++ to be an endlessly rewarding language.

Feel free to share your own C++ oddities and experiences in the comments below. Happy coding!

Exploring the Uncharted: Fun and Weird Stuff in Python

Subham Behera — Thu, 04 Jul 2024 04:37:08 +0000

Python is widely celebrated for its simplicity and readability, making it a favourite among developers and data scientists. But beyond its practical applications, Python has a playful and quirky side that's worth exploring. In this post, I'll take you on a journey through some lesser-known and weird features of Python that can add a bit of fun and surprise to your coding experience.

1. The Zen of Python

Before we dive into the weird stuff, let's start with a hidden gem that provides a philosophical foundation for Python: The Zen of Python. You can access it by importing this:

import this

This will print out a set of aphorisms written by Tim Peters, which serve as guiding principles for writing Python code. It's a great reminder of why Python is such a delightful language.

2. Python's Easter Eggs

Python has several Easter eggs hidden within its standard library. One of the most famous is the "import antigravity" module, which opens a webcomic by XKCD:

import antigravity

Another fun Easter egg is the import hello:

import __hello__

This will print "Hello world!" to the console. These Easter eggs are just for fun and don't serve any practical purpose, but they showcase the playful nature of the Python community.

3. The Walrus Operator

Introduced in Python 3.8, the walrus operator (:=) allows you to assign values to variables as part of an expression. It can make your code more concise and readable in certain situations:

# Traditional way
data = input("Enter something: ")
while data != "quit":
    print(f"You entered: {data}")
    data = input("Enter something: ")

# Using the walrus operator
while (data := input("Enter something: ")) != "quit":
    print(f"You entered: {data}")

4. The else Clause in Loops

Did you know that loops in Python can have an else clause? The else clause executes only if the loop completes normally (i.e., it doesn't encounter a break statement):

for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("Loop completed without break")

for i in range(5):
    print(i)
else:
    print("Loop completed without break")

5. String Formatting

Python offers several ways to format strings, from the older % operator to the format() method and the more recent f-strings (formatted string literals):

name = "Alice"
age = 30

# Using % operator
print("Hello, %s! You are %d years old." % (name, age))

# Using format() method
print("Hello, {}! You are {} years old.".format(name, age))

# Using f-strings
print(f"Hello, {name}! You are {age} years old.")

Conclusion

Python is not just a tool for getting things done; it's also a playground for exploring new ideas and having fun. By delving into these weird and lesser-known features, you can not only enhance your Python skills but also discover the joy and creativity that Python can bring to your coding experience. Happy coding!

DEV Community: Subham Behera

DevSecOps with Github Actions and ArgoCD

Architecture Overview

Step 1: Prepare Ubuntu VM

Step 2: Install Required Tools

Install Dependencies and AWS CLI

Install eksctl

Install kubectl

Install Terraform

Install Helm

Step 3: Configure AWS Credentials

Step 4: Create EKS Cluster

Create the EKS Cluster

Verify Cluster Creation

Step 5: Setup GitHub Repository

Create Repository Structure

Configure GitHub Secrets

Sample GitHub Actions Workflow

Step 6: Install Sealed Secrets

Install Sealed Secrets Controller

Create and Seal Secrets

Step 7: Install and Configure ArgoCD

Install ArgoCD

Get ArgoCD Admin Password

Access ArgoCD UI

Configure Repository Connection

Create Application

Step 8: Verify Deployment

Check Application Status

Access Your Application

Step 9: Test the Complete Pipeline

Make a Code Change

Monitor the Deployment

Note : After completion check if you can see and download the artifact in github actions.

Cleanup

The Bizarre World of JavaScript Type Coercion

Understanding Type Coercion

Type Coercion in Arithmetic Operations

The Infamous NaN and Type Coercion

Coercion in Logical Contexts

The Weirdness of Arrays and Objects

Avoiding Type Coercion Pitfalls

Conclusion

Uncovering Hidden Gems in JavaScript

1. The ?? Nullish Coalescing Operator

Example:

Use Case:

2. The ?. Optional Chaining Operator

Example:

Use Case:

3. The !! Double Bang Operator

Example:

Use Case:

4. The ?.[] Optional Chaining with Dynamic Keys

Example:

Use Case:

5. The Object.fromEntries() Method

Example:

Use Case:

6. The import() Function for Dynamic Imports

Example:

Use Case:

7. The Proxy Object for Meta-Programming

Example:

Use Case:

8. The Reflect API

Example:

Use Case:

9. Tagged Template Literals

Example:

Use Case:

10. The Intl Object for Internationalization

Example:

Use Case:

Conclusion

The Quirky Side of C++: Weird Stuff That Makes Us Love (and Hate) It

1. The Infamous "Most Vexing Parse"

2. Default Arguments in Function Templates

3. The Magic of SFINAE

4. The Curious Case of std::vector<bool>

The Infamous `NaN` and Type Coercion

1. The `??` Nullish Coalescing Operator

2. The `?.` Optional Chaining Operator

3. The `!!` Double Bang Operator

4. The `?.[]` Optional Chaining with Dynamic Keys

5. The `Object.fromEntries()` Method

6. The `import()` Function for Dynamic Imports

7. The `Proxy` Object for Meta-Programming

8. The `Reflect` API

10. The `Intl` Object for Internationalization

4. The Curious Case of `std::vector<bool>`