Important: Git's garbage collection eventually deletes unreachable commits (typically after 30 days), so run this script as soon as you realize something is missing.

#!/bin/bash
#
# git-find-lost-code.sh
# A script to find lost Git commits, stashes, or other changes.
#
# This script searches for "lost" commits in two places:
# 1. Unreachable commits: Commits that are no longer referenced by any branch,
#    tag, or stash. This is where dropped stashes and hard-resets end up.
# 2. The Reflog: A log of all recent movements of HEAD, which acts as a
#    powerful safety net.
#
# USAGE:
#   chmod +x git-find-lost-code.sh
#   ./git-find-lost-code.sh [optional/path/to/file]
#
# If you provide a file path, the script will only show commits that modified
# that specific file. If you don't, it will show ALL lost commits it can find.
# Note: Without a file path, the reflog search may output many commits.

set -e

FILE_PATH="$1"

# --- Method 1: Search Dangling (Unreachable) Commits ---
echo "---"
echo "🔎 Searching for dangling (unreachable) commits..."
echo "---"
UNREACHABLE_COMMITS=$(git fsck --unreachable | grep commit | cut -d' ' -f3)

if [ -z "$UNREACHABLE_COMMITS" ]; then
    echo "No dangling commits found."
else
    FOUND_IN_FSCK=0
    for commit in $UNREACHABLE_COMMITS; do
        if [ -n "$FILE_PATH" ]; then
            # If a file path is provided, check if the commit modified it
            if git show --name-only --pretty="" "$commit" 2>/dev/null | grep -q "^${FILE_PATH}$"; then
                echo "✅ Found dangling commit [$commit] that modified '$FILE_PATH':"
                git log -n 1 --oneline --stat "$commit"
                echo "------------------------------------------------"
                FOUND_IN_FSCK=1
            fi
        else
            # If no file path, just show all dangling commits
            echo "✅ Found dangling commit [$commit]:"
            git log -n 1 --oneline --stat "$commit"
            echo "------------------------------------------------"
            FOUND_IN_FSCK=1
        fi
    done
    if [ "$FOUND_IN_FSCK" -eq 0 ]; then
        echo "No dangling commits found that modified '$FILE_PATH'."
    fi
fi


# --- Method 2: Search The Reflog ---
echo ""
echo "---"
echo "🔎 Searching reflog..."
echo "---"
REFLOG_COMMITS=$(git reflog | awk '{print $1}')

FOUND_IN_REFLOG=0
for commit in $REFLOG_COMMITS; do
    if [ -n "$FILE_PATH" ]; then
        # If a file path is provided, check if the commit modified it
        if git show --name-only --pretty="" "$commit" 2>/dev/null | grep -q "^${FILE_PATH}$"; then
            echo "✅ Found reflog commit [$commit] that modified '$FILE_PATH':"
            git log -n 1 --oneline --stat "$commit"
            echo "------------------------------------------------"
            FOUND_IN_REFLOG=1
        fi
    else
        # If no file path, just show all reflog commits
        echo "✅ Found reflog commit [$commit]:"
        git log -n 1 --oneline --stat "$commit"
        echo "------------------------------------------------"
        FOUND_IN_REFLOG=1
    fi
done

if [ "$FOUND_IN_REFLOG" -eq 0 ]; then
    echo "No commits found in reflog that modified '$FILE_PATH'."
fi

echo ""
echo "✨ Search complete."
echo ""
echo "💡 To recover a commit you found:"
echo "   - Cherry-pick it: git cherry-pick <commit-hash>"
echo "   - Create a branch: git checkout -b recovery-branch <commit-hash>"
echo "   - View the changes: git show <commit-hash>"

How to use

1. Save the script to a file (e.g., git-find-lost-code.sh)
2. Make it executable: chmod +x git-find-lost-code.sh
3. Run it in your Git repository:
   • Find all lost commits: ./git-find-lost-code.sh
   • Find commits that modified a specific file: ./git-find-lost-code.sh path/to/file.txt

Recovering your data

Once you've found the commit you're looking for, you can recover it using:

• Cherry-pick the changes: git cherry-pick <commit-hash>
• Create a new branch from it: git checkout -b recovery-branch <commit-hash>
• View the full changes: git show <commit-hash>
• Apply as a patch: git show <commit-hash> | git apply

#!/usr/bin/env bash

# Function to parse CPU request (in millicores)
parse_cpu() {
  local cpu_str="$1"
  if [[ "$cpu_str" == *"m"* ]]; then
    # Remove "m" and convert to integer
    echo "$(echo "$cpu_str" | sed 's/m//' | awk '{print int($1)}')"
  else
    # Convert to millicores (e.g., "2" -> 2000, "0.5" -> 500)
    echo "$(echo "$cpu_str" | awk '{print int($1 * 1000)}')"
  fi
}

# Function to parse memory request (in Mi)
parse_memory() {
  local mem_str="$1"
  if [[ "$mem_str" == *"Mi"* ]]; then
    echo "$(echo "$mem_str" | sed 's/Mi//' | awk '{print int($1)}')"
  elif [[ "$mem_str" == *"Gi"* ]]; then
    echo "$(echo "$mem_str" | sed 's/Gi//' | awk '{print int($1 * 1024)}')"
  elif [[ "$mem_str" == *"Ki"* ]]; then
    echo "$(echo "$mem_str" | sed 's/Ki//' | awk '{print int($1 / 1024)}')"
  else
    # Assume Mi if no suffix
    echo "$(echo "$mem_str" | awk '{print int($1)}')"
  fi
}


echo "=== Node Allocatable Resources ==="
kubectl get nodes -o json | jq -r '
  .items[]
      node: .metadata.name,
      cpu_allocatable: .status.allocatable.cpu,
      mem_allocatable: .status.allocatable.memory
    }
'

echo ""
echo "=== Pods and Their Total Requests (CPU in m, Mem in Mi) ==="
kubectl get pods -A -o json |
while IFS= read -r line; do
  # Extract relevant data from the JSON using jq and process it
  local namespace=$(echo "$line" | jq -r '.metadata.namespace')
  local pod=$(echo "$line" | jq -r '.metadata.name')
  local node=$(echo "$line" | jq -r '(.spec.nodeName // "-")')

  local cpu_request_m=0
  local mem_request_mi=0

  # Calculate CPU and Memory requests
  local containers=$(echo "$line" | jq -c '.spec.containers[]')
  if [[ -n "$containers" ]]; then
    while IFS= read -r container; do
      local cpu_req_str=$(echo "$container" | jq -r '.resources.requests.cpu // "0"')
      local mem_req_str=$(echo "$container" | jq -r '.resources.requests.memory // "0"')
      cpu_request_m=$((cpu_request_m + $(parse_cpu "$cpu_req_str")))
      mem_request_mi=$((mem_request_mi + $(parse_memory "$mem_req_str")))
    done <<< "$(echo "$containers" | jq -c '.')"
  fi


  # Output the results in TSV format
  echo -e "$namespace\t$pod\t$node\t${cpu_request_m}m\t${mem_request_mi}Mi"
done < <(kubectl get pods -A -o json | jq -c '.items[]')

Also one of the most useful commands I found was:

eks-node-viewer -resources cpu,memory

You can install it with:

brew tap aws/tap
brew install eks-node-viewer

# or

go install github.com/awslabs/eks-node-viewer/cmd/eks-node-viewer@latest

1. Anything that is in the world when you’re born is normal and ordinary and is just a natural part of the way the world works.
2. Anything that's invented between when you’re fifteen and thirty-five is new and exciting and revolutionary and you can probably get a career in it.
3. Anything invented after you're thirty-five is against the natural order of things.

-- Douglas Adams

This blog was generated using gpt-o1-mini AI. You can find the Jupyter Notebook used for its creation here.

The world of web development is undergoing a seismic change, and it's not just about JavaScript frameworks and responsive design anymore. With the advent of artificial intelligence, particularly AI prompting, developers have a chance to elevate their game like never before.

Why AI Prompting?

1. Enhanced Efficiency: Imagine cutting down hours spent on coding tasks by simply asking an AI to generate complex code snippets or solve bugs. AI prompting allows you to harness the power of machine learning to streamline your workflow.

2. Creative Collaboration: AI can serve as a brainstorming partner, helping you come up with unique ideas and solutions that you might not have considered. It's like having a co-developer who's always ready to assist!

3. Continuous Learning: As web technologies evolve rapidly, keeping up is crucial. Learning how to effectively use AI prompting not only enhances your skill set but also positions you at the forefront of this paradigm shift.

4. Empowering Problem Solving: With AI, you can tackle more complex challenges with ease. Whether it's optimizing performance or enhancing user experience, AI can provide insights and solutions based on vast data analysis.

Incorporating AI prompting into your toolkit isn't just an option, it's becoming a necessity. As web developers, we need to embrace this shift and evolve alongside the technology that is reshaping our industry.

Embracing AI prompting is your next step in staying relevant and innovative as web development evolves.

Stay curious, stay ahead!

But progress in a country as vast as ours takes time. By the 2000s, we were seeing results: a booming tech sector, a stronger middle class, and global recognition. These systems weren’t perfect, but they worked because they were built for long-term stability.

Then came 2014, and with it, the BJP. Modi’s government rode in on promises of change, but what they’ve done is disheartening.

Dismantling the Pillars of Progress

The BJP didn’t just claim credit for growth they didn’t build; they also started dismantling the institutions that made it possible:

• Education: Universities and research centers that fuel innovation. With that changing the textbooks to suit their narrative.
• Democracy: A free press, independent judiciary, and robust checks on power. Now it's just a puppet show.
• Economic systems: Policies that supported industry and global integration. Now it's just a mess.
• Taxation: A system that funded development. Now it's just a burden on the common man.

Under BJP rule, these institutions have been weakened. Universities are losing autonomy. The judiciary and press face mounting pressure. The tech industry, which thrived on openness, is being stifled by control-focused policies.

These aren’t just political shifts - they’re generational losses.

The Exodus: Why Many Are Leaving

The erosion of India’s foundational institutions has led to a climate of uncertainty and disillusionment.

In recent years, the rate at which Indians are leaving the country has reached alarming levels, driven by a combination of dwindling opportunities, social tensions, and governance challenges.

As freedoms are curtailed and aspirations are stifled, many are seeking stability, personal security, and better prospects abroad.

This brain drain not only reflects individual choices but also signifies a collective loss for the nation - a drain of talent, innovation, and potential that India can scarcely afford.

Why I Hate the BJP

I hate the BJP because they’re destroying what made modern India possible. The opportunities I had, the systems that supported me, and the stability I relied on are being eroded. What we inherited is slipping away, and future generations will pay the price. My children will grow up in a country that’s less free, less fair, and less prosperous.

This isn’t just bad governance - it’s a betrayal.

A Tribute to Dr. Manmohan Singh

The passing of Dr. Manmohan Singh marks the end of an era. His vision transformed India, from lifting millions out of poverty to building the systems that opened doors for people like me. As a leader, he was quiet yet impactful, focusing on progress over propaganda.

India owes much of its rise to his reforms. His legacy reminds us of what leadership rooted in vision and integrity can achieve.

Looking Ahead

India’s rise wasn’t inevitable-it was built on strong institutions and patient reform. But these gains are fragile, and they’re being hollowed out for short-term power plays.

As citizens, we need to ask: What kind of country do we want to leave behind? Are we okay with trading long-term stability for short-term applause?

We owe it to future generations to rebuild what’s being lost and to demand leadership that values nation-building over credit-grabbing.

In memory of Dr. Manmohan Singh (1932–2024), whose leadership gave India the foundation to dream bigger.

Here's the Nginx configuration I used:

server {
    server_name <HOST_NAME>;

    # ACME Challenge for Certbot
    location ~ "^/\.well-known/acme-challenge/([-_a-zA-Z0-9]+)$" {
        default_type text/plain;
        return 200 "$1.<CERTBOT_CHALLENGE>";
    }

    listen 443 ssl; # managed by Certbot
    ssl_certificate [CERT_PATH]; # managed by Certbot
    ssl_certificate_key [CERT_PATH]; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    add_header Strict-Transport-Security "max-age=7200";

    # Handle /app/* requests
    location /app/ {
        proxy_pass http://127.0.0.1:6001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-Proto https;
    }

    # Handle /terminal/ws requests
    location /terminal/ws {
        proxy_pass http://127.0.0.1:6002;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-Proto https;
    }

    # Handle all other traffic
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-Proto https;
    }
}

server {
    if ($host = <HOST_NAME>) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    server_name <HOST_NAME>;

    listen 80;
    return 404; # managed by Certbot
}

node2  | ERROR 2024-11-03 23:01:03,249 [shard 0:main] init - Startup failed: seastar::internal::backtraced<std::runtime_error> (Failed to start a Raft group 22e5a340-996b-11ef-a7df-a3a43d2a3037: seastar::internal::backtraced<std::runtime_error> (topology[0xe00004c506a0]: node=0xe00004b6f6c0  idx=2 host_id=329b6bdd-3b84-4525-914d-d244cdcec46c endpoint=172.18.0.4 dc=datacenter1 rack=rack1 state=normal shards=1 this_node=false: node endpoint already mapped to node=0xe00004c58240  idx=0 host_id=7e833809-c052-449d-bbc0-b0b51188145f endpoint=172.18.0.4 dc=datacenter1 rack=rack1 state=normal shards=1 this_node=true Backtrace: 0x5325257 0x53257e7 0x4a7d15b 0x4a7ce97 0x517e70b 0x372c547 0x37303fb 0x3733b13 0x36dc667 0x375cbdf 0x390618f 0x38072d3 0x51b6f7b 0x51b8427 0x51b91ff 0x51b889b 0x514f5f3 0x514ead7 0x121b927 0x121cf3f 0x121a3f3 /opt/scylladb/libreloc/libc.so.6+0x30a1b /opt/scylladb/libreloc/libc.so.6+0x30afb 0x1217faf

Looking at the error message, I realized the issue was due to a node endpoint already mapped to another node.

Specifically, the error message says:

Failed to start a Raft group

and

node endpoint already mapped to node=0xe00004c58240  idx=0 host_id=7e833809-c052-449d-bbc0-b0b51188145f endpoint=

To fix it, I removed the existing node mappings and restarted the ScyllaDB cluster.

Fixing ScyllaDB startup issue

• Step 1: Stop the ScyllaDB cluster using the following command:

  docker-compose down
  

• Step 2: Update docker-compose.yml file to use static IP for the nodes, which were available to the nodes when the cluster was started for the first time. For me it was the following configuration:

  services:
    node1:
      image: scylladb/scylla
      container_name: node1
      command: --overprovisioned 1 --smp 1 --reactor-backend=epoll
      networks:
        default:
          ipv4_address: 172.18.0.4
      volumes:
        - /<USER_HOME>/scylladb/data/node1:/var/lib/scylla # Mount node1's data to /var/lib/scylla
  
    node2:
      image: scylladb/scylla
      container_name: node2
      command: --seeds=node1 --overprovisioned 1 --smp 1 --reactor-backend=epoll
      networks:
        default:
          ipv4_address: 172.18.0.3
      volumes:
        - /<USER_HOME>/scylladb/data/node2:/var/lib/scylla # Mount node2's data to /var/lib/scylla
  
    node3:
      image: scylladb/scylla
      container_name: node3
      command: --seeds=node1 --overprovisioned 1 --smp 1 --reactor-backend=epoll
      networks:
        default:
          ipv4_address: 172.18.0.2
      volumes:
        - /<USER_HOME>/scylladb/data/node3:/var/lib/scylla # Mount node3's data to /var/lib/scylla
  
  networks:
    default:
      driver: bridge
      ipam:
      config:
        - subnet: 172.18.0.0/16
          gateway: 172.18.0.1
  

• Step 3: Start the ScyllaDB cluster again using the following command:

  docker-compose up -d
  

The ScyllaDB cluster started successfully after updating the node mappings and restarting the cluster, resolving the issue without any further errors.

The database design is based on several key principles:

• High Scalability: ScyllaDB can scale both horizontally (by adding more nodes) and vertically (by efficiently utilizing modern multi-core CPUs, multi-CPU nodes, and high-capacity storage).
• High Availability: The system maintains low latency and remains operational even if one or more nodes fail or there is a network disruption.
• High Performance: ScyllaDB operates close to the hardware level, ensuring low, consistent latency and high throughput.
• Low Maintenance: It includes user-friendly features such as automated configurations and self-tuning capabilities, reducing the need for manual intervention.

For users familiar with Apache Cassandra®, many ScyllaDB commands and features will feel intuitive. This is because ScyllaDB was designed to be fully compatible with Cassandra at the API level.

My setup script

# Setup scylla db

# Echo get the number of nodes to run
echo "Enter the number of nodes to run"
read num_nodes

# Setup docker network scylla_net if it does not exist
docker network inspect scylla_net > /dev/null 2>&1

if [ $? -eq 1 ]; then
    docker network create scylla_net
fi

# Run scylla db node1
docker run --name node1 --network scylla_net -d scylladb/scylla:6.1.1 --overprovisioned 1 --smp 1 --reactor-backend=epoll

# Seed node with ip of node1
seed_ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' node1)

# Echo seed ip
echo "Seed node ip: $seed_ip"

# Run the rest of the nodes
if [ $num_nodes -gt 1 ]; then
    for i in $(seq 2 $num_nodes); do
        docker run --name node$i --network scylla_net -d scylladb/scylla:6.1.1 --seeds="$seed_ip" --overprovisioned 1 --smp 1 --reactor-backend=epoll
    done
fi

Node

A node is the fundamental building block of a ScyllaDB database, consisting of the ScyllaDB server software running on a physical or virtual server.

Each node holds a portion of the overall database cluster's data and is divided into multiple independent shards.

In ScyllaDB, all nodes are equal, with no master or slave roles. Every node is capable of handling requests, and they collaborate to ensure continuous service, even if one node becomes unavailable due to a failure.

Keyspace and Table

A Keyspace is a collection of tables with settings that determine how data is replicated across nodes (Replication Strategy). It includes several options that apply to all the tables within it. Typically, it's advised to use one Keyspace per application, so a cluster might have only a single Keyspace.

A Table represents how ScyllaDB organizes and stores data, functioning as a collection of rows and columns.

Cluster – Node Ring

A Cluster in ScyllaDB is a collection of nodes used to store and manage data, with the nodes arranged in a logical ring structure. Typically, a cluster consists of at least three nodes, and data is automatically replicated across these nodes based on the defined Replication Factor.

This ring-like architecture is based on a hash ring, which guides how data is distributed across the nodes within the cluster.

Clusters can scale dynamically, either by adding nodes to increase storage and processing capabilities or by removing nodes through planned decommissioning or in response to failures. When the cluster's topology changes, ScyllaDB automatically reconfigures itself to rebalance the data.

While a ScyllaDB cluster requires a minimum of three nodes, it can scale to include hundreds. Communication between nodes within the cluster is peer-to-peer, eliminating any single point of failure. For external communication, such as read or write operations, a ScyllaDB client connects to a single node called the coordinator. This coordinator is selected for each client request, preventing any one node from becoming a bottleneck. Further details on this process are provided later in the lesson.

A Partition Key consists of one or more columns that determine how data is distributed across the nodes. It decides where a specific row will be stored. Typically, data is replicated across multiple nodes, ensuring that even if one node fails, the data remains accessible, providing reliability and fault tolerance.

For example, if the Partition Key is the ID column, a consistent hash function will determine which nodes store the data.

ScyllaDB transparently partitions and distributes data throughout the cluster. Data replication ensures availability, and the cluster is visualized as a ring, where each node manages a range of tokens. Each data value is associated with a token using a partition key:

Data Replication

To eliminate any single point of failure, ScyllaDB uses data replication, which involves storing copies of data across multiple nodes. This ensures that even if one node fails, the data remains accessible, providing reliability and fault tolerance. The number of copies, or Replication Factor (RF), determines how many times the data is duplicated.

For instance, a Replication Factor of 3 (RF=3) means that three copies of the data are maintained at all times. Users set the RF for a specific keyspace, and based on this setting, the coordinator distributes the data to other nodes, known as replicas, to ensure redundancy and fault tolerance.

Shard

Each ScyllaDB node is divided into several independent shards, with each shard managing a portion of the node's data. ScyllaDB allocates one shard per core (technically, one per hyperthread, meaning a physical core may support multiple virtual cores). Each shard follows a shared-nothing architecture, meaning it has dedicated RAM and storage, manages its own CPU and I/O scheduling, performs compactions (explained further later), and maintains its own multi-queue network connection. Shards operate as single threads and communicate asynchronously with each other without the need for locking.

From an external perspective, nodes are treated as unified entities, with operations executed at the node level.

Datacenter

A datacenter is a physical facility that houses servers, storage systems, and networking equipment. Cloud providers operate multiple datacenters across various countries worldwide.

ScyllaDB is designed to be fault-tolerant at the software level and is also aware of the datacenter's topology. For instance, you might want to place replica nodes on different racks within a datacenter to reduce the risk of disruptions caused by rack-specific network or power failures. ScyllaDB manages this using a mechanism called snitches.

A Rack is a metal framework that holds hardware components such as servers, hard drives, and networking devices. ScyllaDB recognizes logical racks to add an extra layer of fault tolerance, ensuring that if one rack (or even an entire datacenter) fails, data remains accessible.

ScyllaDB also supports multi-datacenter replication, enabling data sharing and distribution across two or more datacenters. The replication strategy allows you to specify the number of datacenters for replication and set distinct replication factors for each one.

Datacenters in ScyllaDB are configured in a peer-to-peer manner, meaning there is no central authority, nor are there "primary/replica" hierarchical relationships between clusters.

This setup enables data replication across clusters to handle localized traffic with minimal latency and high throughput, and to ensure resilience in case of a complete datacenter outage.

Replication Strategy

The Replication Strategy defines how replicas are distributed across nodes. ScyllaDB offers two replication strategies:

• SimpleStrategy: The first replica is placed on the node determined by the partitioner, which is a hash function used to map data to specific nodes in the cluster. Subsequent replicas are positioned clockwise around the node ring. This strategy is not recommended for production environments.
• NetworkTopologyStrategy: Replicas are placed clockwise around the ring until a node on a different rack is reached. This strategy is ideal for clusters spread across multiple datacenters, as it allows you to specify the number of replicas for each datacenter.

For example, if there are two datacenters, DC1 with a replication factor of 3 and DC2 with a replication factor of 2, the overall replication factor for the keyspace would be 5. Below, we'll demonstrate how to create such a keyspace.

Token Ranges

In a ScyllaDB ring, each node is responsible for a specific token range. The hash function generates a token based on the partition key, which determines where the data is stored within the cluster.

Without virtual nodes (Vnodes), each node would manage only a single token range. However, with Vnodes, each physical node can handle multiple, non-contiguous token ranges, effectively allowing it to act as many virtual nodes. By default, each physical node is configured to host 256 virtual nodes.

Consistency Level (CL)

The number of nodes that must confirm a read or write operation before it is considered successful is defined by the consistency level.

To ensure data is correctly written or read, a sufficient number of nodes need to agree on its current state. Although consistency levels can be set globally for all operations (on the client side), ScyllaDB allows each read or write operation to have its own specific consistency level, a feature known as tunable consistency.

Here are some common consistency levels:

• CL of 1: Wait for a response from a single replica node.
• CL of ALL: Wait for a response from all replica nodes.
• CL LOCAL_QUORUM: Wait for responses from a majority of replica nodes in the local datacenter, calculated as floor((#dc_replicas / 2) + 1). For example, if a datacenter has 3 replica nodes, the operation will wait for a response from 2 nodes.
• CL EACH_QUORUM: In multi-datacenter setups, each datacenter must reach a LOCAL_QUORUM. This level is not supported for read operations.
• CL ALL: Requires responses from all replica nodes, providing the highest level of consistency but at the cost of reduced availability.

Since data may be updated on the coordinator node but not yet fully replicated across all nodes, ScyllaDB implements eventual consistency. With this model, all replicas will eventually synchronize to the same data state, even as operations continue to update the database.

Cluster Level Read/Write Interaction

So what happens when data is read or written at the cluster level? Note that what happens at the node level will be explained in another lesson.

Since each node is equal in ScyllaDB, any node can receive a read/write request. These are the main steps in the process: ]

1. A client connects to a ScyllaDB node using the CQL shell and performs a CQL request
2. The node the client is connected to is now designated as the Coordinator Node. The Coordinator Node, based on hashing the data, using the partition key and on the Replication Strategy, sends the request to the applicable nodes. Internode messages are sent through a messaging queue asynchronously.
3. The Consistency Level determines the number of nodes the coordinator needs to hear back from for the request to be successful.
4. The client is notified if the request is successful.

Gossip

ScyllaDB, similar to Apache Cassandra, employs a decentralized internode communication protocol known as Gossip. This protocol allows nodes to exchange information without relying on a single point of failure. Gossip is used for tasks such as peer node discovery and the distribution of metadata across the cluster. Communication happens periodically, with each node interacting with three other nodes. Over a short period (usually a few seconds), this information spreads throughout the entire cluster.

Snitch

The Snitch in ScyllaDB determines which racks and datacenters should be used for reading and writing data. ScyllaDB offers the following types of snitches:

• SimpleSnitch: The default option, recommended only for single datacenter clusters.
• RackInferringSnitch: Assigns nodes to datacenters and racks based on their broadcast IP addresses.
• GossipingPropertyFileSnitch: Explicitly defines the rack and datacenter for each node. Preferred over SimpleSnitch for better configuration.
• Ec2Snitch: Automatically detects the cluster topology using the AWS API, suitable for single-region deployments on AWS where the region acts as a datacenter.
• Ec2MultiRegionSnitch: Similar to Ec2Snitch but designed for clusters spread across multiple AWS regions.
• GoogleCloudSnitch: Designed for ScyllaDB deployments on Google Cloud Engine (GCE). Treats regions as datacenters and availability zones as racks within those datacenters.

My ScyllaDB docker-compose setup

services:
  node1:
    image: scylladb/scylla
    container_name: node1
    command: --overprovisioned 1 --smp 1 --reactor-backend=epoll
    volumes:
      - ./data/node1:/var/lib/scylla

  node2:
    image: scylladb/scylla
    container_name: node2
    command: --seeds=node1 --overprovisioned 1 --smp 1 --reactor-backend=epoll
    volumes:
      - ./data/node2:/var/lib/scylla

  node3:
    image: scylladb/scylla
    container_name: node3
    command: --seeds=node1 --overprovisioned 1 --smp 1 --reactor-backend=epoll
    volumes:
      - ./data/node3:/var/lib/scylla

• Consistency
• Availability
• Partition Tolerance

However the CAP theorem states that there is a trade off between these three attributes, we can only choose two out of these three

Availability

We still be able to serve requests when there is some kind of failure. When some of our nodes in our distributed system become unavailable.

This is done by replicating data. For each piece of data, we have multiple copies spread across multiple DBs.

Consistency

For our read request we will always get the latest write.

Partition Tolerance

In case of a network failure between nodes, the system should work and try to get back to consistent state when failure disappears.

Examples

CP databases

• Apache HBase
• MongoDB

AP databases

• ScyllaDB
• Casandra
• DynamoDB

CA databases

• Vertica
• MySQL
• Postgres

This doesn't mean databases don't have all three attributes. But the databases favours certain attributes in favour of other in case of a failure.

Helm upgrade failed: resource mapping not found for name: "<RELEASE_NAME>" namespace: "" from "": no matches for kind "HorizontalPodAutoscaler" in version "autoscaling/v2beta1"

To fix this I did the following:

1. Installed the helm-mapkubeapis plugin

helm plugin install https://github.com/helm/helm-mapkubeapis

2. Run the plugin to update the resource mapping

helm mapkubeapis <RELEASE_NAME>

3. Upgrade/Delete the Helm chart

helm upgrade <RELEASE_NAME> <CHART_NAME>

# or

helm delete <RELEASE_NAME>

To allow any unknown developer app on macOS, you can use the following command in the terminal.

sudo spctl --master-disable

Then go to System Preferences -> Privacy & Security -> scroll down to Security -> Allow Applications from -> Anywhere

This will allow you to install any app on macOS without any restrictions. But be careful, as this will allow you to install any app on your system.

• Repeat and Missing Number Array (InterviewBit)
• Find a Repeating and a Missing Number (GeeksforGeeks)
• Find Two Non-Repeating Elements in an Array (GeeksforGeeks)
• Find Maximum Sum Triplets (GeeksforGeeks)
• Stock Buy Sell (GeeksforGeeks)
• Find Maximum Number Possible by Doing at Most K Swaps (GeeksforGeeks)
• Minimum Number of Jumps to Reach End (GeeksforGeeks)
• Longest Increasing Subsequence (LeetCode) (Video Explanation)
• Form the Biggest Number (GeeksforGeeks)
• Search a Word in a 2D Grid (GeeksforGeeks)
• Trapping Rain Water (LeetCode)
• Max Points on a Line (LeetCode)
• Check If Array Pairs Are Divisible by K (LeetCode)
• Merge Intervals (LeetCode)
• Subarray Product Less Than K (LeetCode)
• 3Sum (LeetCode)
• Set Matrix Zeroes (LeetCode)
• Range Sum Query 2D (LeetCode)
• First Missing Positive (LeetCode)
• Top K Frequent Elements (LeetCode)
• Longest Palindromic Substring (LeetCode)
• Sort Colors (LeetCode)
• Maximum Points You Can Obtain from Cards (LeetCode)

Hashing

• 4Sum II (LeetCode)
• Longest Consecutive Sequence (LeetCode)
• LRU Cache (LeetCode)
• Longest Substring with Equal 1s and 0s (GeeksforGeeks)
• Range Module (LeetCode)
• My Calendar I (LeetCode)
• My Calendar II (LeetCode)
• My Calendar III (LeetCode)
• Time-Based Key-Value Store (LeetCode)

Cyclic Sort

• Minimum Number of Swaps Required to Sort an Array (GeeksforGeeks)

Sorting

• Kth Largest Element in an Array (LeetCode)
• Count of Smaller Numbers After Self (LeetCode)
• Reverse Pairs (LeetCode)
• Top K Frequent Elements (LeetCode)

LinkedList

• Partition List (InterviewBit)
• Partition List (LeetCode)
• Palindrome List (InterviewBit)
• Palindrome Linked List (LeetCode)
• List Cycle (InterviewBit)
• Flattening a Linked List (GeeksforGeeks)
• Reverse a List in Groups (GeeksforGeeks)
• Reverse Nodes in K-Group (LeetCode)

String

• Group Anagrams (LeetCode)
• Find the Smallest Window Containing All Characters (GeeksforGeeks)
• Minimum Window Subsequence (LeetCode)
• Longest Substring with at Most K Distinct Characters (LeetCode)

Binary Search

• Allocate Minimum Number of Pages (GeeksforGeeks)
• Woodcutting Made Easy (InterviewBit)
• Kth Smallest Element in a Sorted Matrix (LeetCode)
• Maximum Length Possible by Cutting Woods (GeeksforGeeks)
• Median of Two Sorted Arrays (LeetCode)
• Kth Element in Two Sorted Arrays (GeeksforGeeks)

Heaps & Priority Queues

• Merge K Sorted Linked Lists Using Min-Heap (GeeksforGeeks)
• Merge K Sorted Lists (LeetCode)
• Nearly Sorted Algorithm (GeeksforGeeks)
• Top K Frequent Words (LeetCode)
• Find Median from Data Stream (LeetCode)
• Minimum Cost of Ropes (GeeksforGeeks)
• Sliding Window Median (LeetCode)
• Max Value of Equation (LeetCode)
• Trapping Rain Water II (LeetCode)

Stacks/Queues

• Sliding Window Maximum (GeeksforGeeks)
• Design a Stack That Supports GetMin (GeeksforGeeks)
• Min Stack (LeetCode)
• First Non-Repeating Character in a Stream (InterviewBit)
• Zigzag Tree Traversal (GeeksforGeeks)
• Binary Tree Zigzag Level Order Traversal (LeetCode)
• Sort a Stack Using Recursion (GeeksforGeeks)
• Largest Rectangle in Histogram (LeetCode)
• Maximal Rectangle (LeetCode)
• Max Rectangle in Binary Matrix (InterviewBit)
• Next Greater Element I (LeetCode)
• Valid Parenthesis String (LeetCode)
• Decode String (LeetCode)
• Car Fleet II (LeetCode)

Greedy

• Minimum Number of Platforms Required (GeeksforGeeks)
• Majority Element (GeeksforGeeks)
• Minimize Cash Flow Among Friends (GeeksforGeeks)
• Maximum Number of Overlapping Intervals (GeeksforGeeks)
• Task Scheduler (LeetCode)
• Guess the Word (LeetCode)
• Sentence Screen Fitting (LeetCode)
• Maximum Number of Events That Can Be Attended (LeetCode)
• Queue Reconstruction by Height (LeetCode)
• Random Pick with Blacklist (LeetCode)
• Random Pick with Blacklist - Java Discussion (LeetCode)
• Video Stitching (LeetCode)

Trees

• Check if Array Can Represent Preorder Traversal of BST (GeeksforGeeks)
• 2 Sum Binary Tree (InterviewBit)
• Find a Pair with Given Sum in BST (GeeksforGeeks)
• Two Sum IV - Input is a BST (LeetCode)
• Construct Binary Tree from Postorder and Inorder (GeeksforGeeks)
• Find Minimum Depth of a Binary Tree (GeeksforGeeks)
• Least Common Ancestor (InterviewBit)
• Flatten Binary Tree to Linked List (InterviewBit)
• Flatten Binary Tree to Linked List (LeetCode)
• Sorted Linked List to Balanced BST (GeeksforGeeks)
• Convert Sorted List to Binary Search Tree (LeetCode)
• Inorder Tree Traversal Without Recursion (GeeksforGeeks)
• Symmetric Tree - Tree Mirror Image of Itself (GeeksforGeeks)
• Minimum Iterations to Pass Information in Nodes (GeeksforGeeks)
• Query Ancestor-Descendant Relationship in Tree (GeeksforGeeks)
• Check if a Binary Tree is BST (GeeksforGeeks)
• Print Nodes at Distance K in Binary Tree (GeeksforGeeks)
• Construct BST from Preorder Traversal (GeeksforGeeks)
• Serialize/Deserialize Binary Tree (GeeksforGeeks)
• Shortest Distance Between Two Nodes in BST (GeeksforGeeks)
• Merge Two Binary Trees (InterviewBit)
• Binary Tree Zigzag Level Order Traversal (LeetCode)
• Connect Nodes at Same Level with O(1) Space (GeeksforGeeks)
• Maximum XOR of Two Numbers in an Array (LeetCode)
• Sum of Distances in Tree (LeetCode)
• Find Duplicate Subtrees (LeetCode)
• Binary Search Tree - Delete (GeeksforGeeks)
• Delete Node in a BST (LeetCode)
• Recover Binary Search Tree (LeetCode)
• Smallest Subtree with All the Deepest Nodes (LeetCode)
• Lowest Common Ancestor of Deepest Leaves (LeetCode)

Trie

• Find All Shortest Unique Prefixes to Represent Words (GeeksforGeeks)
• Shortest Unique Prefix (InterviewBit)
• Print All Anagrams Together (GeeksforGeeks)
• Design Search Autocomplete System (LeetCode)

DSU (Disjoint Set Union)

• Accounts Merge (LeetCode)
• Most Stones Removed with Same Row or Column (LeetCode)
• Checking Existence of Edge Length Limited Paths (LeetCode)

Graph

• Diameter of Binary Tree (LeetCode)
• Longest Path in an Undirected Tree (GeeksforGeeks)
• Topological Sorting (GeeksforGeeks)
• Clone an Undirected Graph (GeeksforGeeks)
• Word Ladder I (InterviewBit)
• Word Ladder Length of Shortest Chain (GeeksforGeeks)
• Detect Cycle in an Undirected Graph (GeeksforGeeks)
• Detect Cycle in a Graph (GeeksforGeeks)
• Find Precedence of Characters (GeeksforGeeks)
• Minimum Time for All Oranges to Rot (GeeksforGeeks)
• Graph Coloring - Greedy Algorithm (GeeksforGeeks)
• Snake and Ladder Problem (GeeksforGeeks)
• Dijkstra's Shortest Path Algorithm (GeeksforGeeks)
• 0/1 Matrix (LeetCode)
• Count Vowels Permutation (LeetCode)
• Count Vowels Permutation Discussion (LeetCode)
• Number of Ways to Paint N x 3 Grid (LeetCode)
• Critical Connections in a Network (LeetCode)
• Redundant Connection (LeetCode)
• Longest Increasing Path in a Matrix (LeetCode)
• Course Schedule II (LeetCode)
• Cheapest Flights Within K Stops (LeetCode)
• Path with Minimum Effort (LeetCode)
• String Transforms into Another String (LeetCode)
• Pacific Atlantic Water Flow (LeetCode)
• Path Rectangle Containing Circles (GeeksforGeeks)
• Couples Holding Hands - Java Solution (LeetCode)
• Couples Holding Hands (LeetCode)
• Minimum Cost to Make At Least One Valid Path in a Grid (LeetCode)
• 0-1 BFS Shortest Path in a Binary Graph (GeeksforGeeks)
• Shortest Path Visiting All Nodes (LeetCode)
• Shortest Path with Alternating Colors (LeetCode)
• Steps by Knight (GeeksforGeeks)
• Best Meeting Point (LeetCode)
• Shortest Distance from All Buildings (LeetCode)
• Walls and Gates (LeetCode)
• Confusing Number II (LeetCode)
• The Most Similar Path in a Graph (LeetCode)
• Jump Game IV (LeetCode)
• Loud and Rich (LeetCode)
• Where Will the Ball Fall (LeetCode)
• Count Pairs of Nodes (LeetCode)

DP (Dynamic Programming)

• Longest Palindromic Subsequence (GeeksforGeeks)
• Longest Palindromic Subsequence (LeetCode)
• Champagne Tower (LeetCode)
• Subset Sum Problem (GeeksforGeeks)
• Longest Common Subsequence (InterviewBit)
• Best Time to Buy and Sell Stock III (LeetCode)
• Best Time to Buy and Sell Stock III (YouTube)
• Best Time to Buy and Sell Stock IV (LeetCode)
• Best Time to Buy and Sell Stock IV (YouTube)
• Best Time to Buy and Sell Stock with Cooldown (LeetCode)
• Maximum Product Subarray (LeetCode)
• Decode Ways (LeetCode)
• Word Break II (LeetCode)
• Split Array Largest Sum (LeetCode)
• Perfect Squares (LeetCode)
• Minimum Cost for Tickets (LeetCode)
• Minimum Cost for Tickets Discussion (LeetCode)
• 2 Keys Keyboard (LeetCode)
• Dungeon Game (LeetCode)
• Dungeon Game (YouTube)
• Longest Arithmetic Subsequence (LeetCode)
• Triangle (LeetCode)
• Minimum Number of Refueling Stops (LeetCode)
• Best Time to Buy and Sell Stock with Transaction Fee (LeetCode)
• Encode String with Shortest Length (LeetCode)
• Regular Expression Matching (LeetCode)
• Minimum Swaps to Make Sequences Increasing (LeetCode)
• Stone Game III (LeetCode)
• Maximum Sum of 3 Non-Overlapping Subarrays (LeetCode)
• Burst Balloons (LeetCode)
• Predict the Winner (LeetCode)
• Optimal Strategy for a Game (GeeksforGeeks)
• Palindrome Partitioning (GeeksforGeeks)
• As Far from Land as Possible (LeetCode)
• Russian Doll Envelopes (LeetCode)
• Minimum Number of Removals to Make Mountain Array (LeetCode)
• Binary Tree Cameras (LeetCode)
• Make Array Strictly Increasing (LeetCode)
• Make Array Strictly Increasing Discussion (LeetCode)
• Race Car (LeetCode)
• New 21 Game (LeetCode)
• Cherry Pickup II (LeetCode)
• Cherry Pickup (LeetCode)
• House Robber III (LeetCode)

Now they're getting married and moving on with their lives. I'm happy for them and you should be too.

P.S. This song perfectly sums up everything. Happy New Year!

• Requirements Gathering and Planning:

  • Understanding user needs and system requirements is crucial. This helps in designing an application that meets performance expectations and quality standards.
  • Setting clear performance goals as part of the non-functional requirements.

• Design and Architecture:

  • Adopting a robust and scalable architecture that can handle the anticipated load and allows for future expansion.
  • Using design patterns that promote modularity, reusability, and maintainability.

• Development Practices:

  • Writing efficient and optimized code to enhance performance.
  • Utilizing frameworks and libraries that are known for their performance and reliability.
  • Implementing responsive design principles to ensure the application adapts to different device screens and resolutions.

• Testing:

  • Conducting various types of testing such as unit testing, integration testing, system testing, and user acceptance testing to ensure quality.
  • Performing performance testing to identify bottlenecks and optimize the system’s response time, throughput, and scalability.
  • Using automated testing tools to ensure continuous quality control.

• Deployment:

  • Optimizing server configurations and resources based on the application’s needs.
  • Implementing load balancing and clustering for high-availability applications.

• Monitoring and Maintenance:

  • Continuously monitoring the application’s performance using tools that can track response times, server health, and error rates.
  • Regularly updating the application and its dependencies to the latest versions for performance improvements and security patches.
  • Analyzing user feedback and usage patterns to make iterative improvements.

• Scalability:

  • Designing the application with scalability in mind, so it can handle increased loads without a significant drop in performance.
  • Using cloud services and technologies that allow for easy scaling up or down based on demand.

• Security Considerations:

  • Ensuring that security measures do not adversely impact performance.
  • Balancing security needs with usability to maintain a responsive user experience.

• User Experience:

  • Focusing on the frontend performance to reduce load times and enhance interactivity.
  • Simplifying the user interface to improve responsiveness and ease of use.

• Feedback Loop:

  • Establishing a feedback loop with end-users to continuously gather insights on performance and usability, allowing for timely improvements.

Each of these steps plays a critical role in ensuring that the application not only meets its performance targets but also provides a high-quality and responsive experience for its users.

Here's a simple example of a functor in C++:

#include <iostream>

using namespace std;

class Adder {
public:
    Adder(int n) : n_(n) {}

    int operator()(int x) const {
        return x + n_;
    }

private:
    int n_;
};

int main() {
    Adder addFive(5);
    cout << "Result: " << addFive(3) << endl; // Result: 8
    return 0;
}

In this example, Adder is a functor. It is initialized with a number, and when it is called as a function, it adds this number to its argument. The operator() method makes this possible. This pattern is particularly useful in C++ for things like custom comparison functions in sorting algorithms, or for creating small function objects that carry state.

Why is functor useful?

The key difference between using a functor and simply passing an additional variable to a function in C++ lies in the encapsulation of both state and behavior, as well as the potential for increased flexibility and efficiency.

1. Encapsulation of State and Behavior:

   • A functor encapsulates both data (state) and a specific operation (behavior) in one object. In the Adder example, the state is the value to add (n_), and the behavior is the addition operation itself.
   • In contrast, passing an extra variable to a function only provides additional data. The function's behavior is fixed and cannot be changed unless you modify the function's code.

2. Object-Oriented Approach:

   • Functors align well with object-oriented programming principles. They allow you to bundle data and functionality together, and they can also inherit from other classes or implement interfaces.
   • Passing additional variables does not inherently leverage object-oriented principles.

3. Flexibility and Reusability:

   • Functors can be more flexible. For instance, you can create different functor classes that implement the same interface but perform different operations. This makes it easy to swap out one functor for another without changing the code that uses them.
   • With a simple variable, this level of flexibility is not achievable. The function that uses the variable is limited to a specific operation defined in its implementation.

4. Efficiency in Certain Contexts:

   • In some cases, using functors can be more efficient, especially in templated code like in the Standard Template Library (STL). Functors can be inlined by the compiler, potentially leading to more efficient code than using a pointer to a function.
   • Passing a variable doesn't have this potential for compiler optimization in the context of the operation's implementation.

5. Compatibility with STL and Other Libraries:

   • Functors are widely used in C++ standard libraries, such as for custom comparison functions in sorting algorithms. They are designed to be used where the library expects an object that can be called like a function.
   • While passing variables is a common practice, it doesn't serve the same purpose as a functor in the context of these libraries.

In summary, functors offer a more encapsulated, flexible, and potentially efficient way to bundle data and operations together, aligning with object-oriented principles and offering advantages particularly in templated and library code. Passing additional variables to functions is a simpler approach but lacks these advantages.

Common operations

• Access
• Set
• Remove
• Traverse/Search
  • For a key
  • For a value

Big O

Given two strings s and t, determine if they are isomorphic. Two strings s and t are isomorphic if the characters in s can be replaced to get t. All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself. s and t consist of any valid ascii character.

Solution

Code

Brute force

#include <cstdio>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

bool checkPair_slow(vector<int> arr, int target) {

  for (int i = 0; i < arr.size(); i++) {
    for (int j = i; j < arr.size(); j++) {
      if (arr[i] + arr[j] == target)
        return true;
    }
  }

  return false;
}

int main() {

  vector<int> arr = {3, 2, 7, 6, 5, 3, 2, 7, 12, 15, 1};

  printf(checkPair(arr, 54) ? "t" : "f");
  printf("\n");

  return 0;
}

Hashmap

#include <cstdio>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

bool checkPair(vector<int> arr, int target) {
  unordered_map<int, int> umap;
  for (int i = 0; i < arr.size(); i++) {
    if (umap.find(target - arr[i]) != umap.end()) {
      return true;
    } else {
      umap[arr[i]] = i;
    }
  }
  return false;
}

int main() {

  vector<int> arr = {3, 2, 7, 6, 5, 3, 2, 7, 12, 15, 1};

  printf(checkPair(arr, 54) ? "t" : "f");
  printf(checkPair_slow(arr, 54) ? "t" : "f");
  printf("\n");

  return 0;
}

You are given an array of Integers and another integer targetValue. Write a function that will take these inputs and return the indices of the 2 integers in the array that add up targetValue.

Solution

Brute force

The brute force solution is quite simple. We can use 2 loops to iterate over the array and check if the sum of the 2 numbers is equal to the targetValue. If it is, we can return the indices of the 2 numbers.

Hash table

We can use a hash table to store the numbers and their indices. Then we can iterate over the array and check if the difference between the targetValue and the current number is in the hash table. If it is, we can return the indices of the 2 numbers.

Code

Brute force

vector<int> twoSum(vector<int>& nums, int target) {
    for(int i = 0; i < nums.size(); i++) {
        for(int j = i + 1; j < nums.size(); j++) {
            if(nums[i] + nums[j] == target) {
                return {i, j};
            }
        }
    }
    return {};
}

Hash table

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> hash;
    for(int i = 0; i < nums.size(); i++) {
        if(hash.find(target - nums[i]) != hash.end()) {
            return {hash[target - nums[i]], i};
        }
        hash[nums[i]] = i;
    }
    return {};
}

Types

• Static arrays
• Dynamic arrays

Common operations

• Access
• Set
• Traverse/Search
• Copy
• Insert
  • at beginning
  • at end
  • somewhere in middle
• Remove
  • at beginning
  • at end
  • somewhere in middle

Big O

An array is monotonic if it is either monotone increasing or monotone decreasing. An array is monotone increasing if all its elements from left to right are non-decreasing. An array is monotone decreasing if all its elements from left to right are non-increasing. Given an integer array return true if the given array is monotonic, or false otherwise.

Solution

The solution is quite simple. We can iterate over the array and check if it is monotone increasing or monotone decreasing. If it is neither, then it is not monotonic.

Code

#include <iostream>
#include <vector>

bool isMonotonic(std::vector<int> &arr) {
    bool increasing = true;
    bool decreasing = true;
    for (int i = 1; i < arr.size(); i++) {
        if (arr[i] < arr[i - 1]) {
            increasing = false;
        }
        if (arr[i] > arr[i - 1]) {
            decreasing = false;
        }
    }
    return increasing || decreasing;
}

int main() {
    std::vector<int> arr = {1, 2, 3, 4, 5};
    std::cout << isMonotonic(arr) << std::endl;
    return 0;
}

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]). Find two lines that together with the x-axis form a container, such that the container contains the most water(depth is constant across containers). Return the area(that the 2 lines and the X axis make) of container which can store the max amount of water. Notice that you may not slant the container.

Solution

Brute force

Keeping the height of the container constant, we can find the width of the container by iterating over all possible combinations of two lines. This would take O(n^2) time and O(1) space.

Optimized

We can use a two pointer approach to solve this problem in O(n) time and O(1) space. We start with two pointers, one at the start and one at the end of the array. We calculate the area of the container formed by these two lines and move the pointer with the smaller height inwards. This is because the area of the container is limited by the smaller height. We keep doing this until the two pointers meet. We return the maximum area we have seen so far.

Code

Brute force

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

int area_with_most_water(vector<int> list) {
  int len = list.size();
  if (len < 2)
    return 0;

  int max_area = 0;
  for (int i = 0; i < len; i++) {
    int left_height = list[i];
    for (int j = i + 1; j < len; j++) {
      int distance = j - i;
      int right_height = list[j];
      int min_height = right_height > left_height ? left_height : right_height;
      int area = min_height * distance;
      if (area > max_area) {
        max_area = area;
      }
    }
  }
  return max_area;
}

int main() {
  vector<int> arr = {3, 1, 2, 4, 5};
  printf("Largest storeable area: %d\n", area_with_most_water_fast(arr));
  return 0;
}

Optimized

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;


int area_with_most_water_fast(vector<int> lines) {

  int len = lines.size();

  // there needs to be atleast 2 lines to form an area with the x-axis as basis
  if (len <= 1)
    return 0;

  int start = 0;
  int end = len - 1;

  int area = 0;

  while (start < end) {

    int distance = end - start;
    area = max(area, min(lines[start], lines[end]) * distance);

    if (lines[start] < lines[end]) {
      start += 1;
    } else {
      end -= 1;
    }
  }
  return area;
}

int main() {

  vector<int> arr = {3, 1, 2, 4, 5};

  printf("Largest storeable area: %d\n", area_with_most_water_fast(arr));

  return 0;
}

Given an array, rotate the array to the right by k steps, where k is non-negative.

Solution

With extra space

The solution is quite simple. We can use a temporary array to store the elements that will be rotated. Then we can copy the elements from the temporary array to the original array.

Without extra space

The solution is quite simple. We can reverse the array. Then we can reverse the first k elements and the last n - k elements.

Code

With extra space

#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

// rotate right
vector<int> rotate_arr_right(int k, vector<int> arr) {
  int len = arr.size();
  int finalShift = k % len;
  if (finalShift == 0)
    return arr;
  vector<int> newArr(len, 0);

  for (int i = 0, j = k; i < len; j = (j + 1) % len, i++) {
    newArr[j] = arr[i];
  }
  return newArr;
}

int main() {
  vector<int> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  vector<int> newArr = rotate_arr_right(3, arr);
  for (int i = 0; i < newArr.size(); i++) {
    printf("%d ", newArr[i]);
  }
  printf("\n");
  return 0;
}

Without extra space

#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

void x_reverse(vector<int> &arr, int startIdx, int endIdx) {
  if (startIdx > endIdx || startIdx >= arr.size() || endIdx >= arr.size())
    throw invalid_argument("invalid index");
  if (endIdx - startIdx <= 1)
    return;
  while (startIdx <= endIdx) {
    int temp = arr[startIdx];
    arr[startIdx] = arr[endIdx];
    arr[endIdx] = temp;
    startIdx += 1;
    endIdx -= 1;
  }
}

void print_arr(vector<int> &arr) {

  for (int i = 0; i < arr.size(); i++) {
    printf("%d ", arr[i]);
  }
}

// rotate right without extra space
void rotate_arr(int k, vector<int> &arr) {
  int len = arr.size();
  int finalShift = k % len;
  printf("finalShift: %d\n", finalShift);
  if (finalShift == 0)
    return;
  // reverse full arr
  x_reverse(arr, 0, len - 1);
  //  print_arr(arr);
  // reverse again from 0 -> finalShift
  x_reverse(arr, 0, finalShift - 1);
  //  print_arr(arr);
  // reverse again from finalShift -> len
  x_reverse(arr, finalShift, len - 1);
  //  print_arr(arr);
}


int main() {
  vector<int> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  rotate_arr(3, arr);
  for (int i = 0; i < arr.size(); i++) {
    printf("%d ", arr[i]);
  }
  printf("\n");
  return 0;
}

Sorted Squared Array - You are given an array of Integers in which each subsequent value is not less than the previous value. Write a function that takes this array as an input and returns a new array with the squares of each number sorted in ascending order.

Solution

Brute force

The brute force solution is to square each element and then sort the array. This would take O(nlogn) time and O(n) space.

Optimized

The optimized solution is to use two pointers, one at the beginning and one at the end of the array. Compare the squares of the two pointers and add the larger one to the result array. Then move the pointer of the larger value towards the center of the array. Repeat this process until the two pointers meet. This would take O(n) time and O(n) space.

Code

#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

vector<int> sort_squared_slow(vector<int> arr) {

  int len = arr.size();
  vector<int> newArr(len, 0);

  for (int i = 0; i < len; i++) {
    newArr[i] = arr[i] * arr[i];
  }
  sort(newArr.begin(), newArr.end());
  return newArr;
}

vector<int> sort_squared(vector<int> arr) {
  int len = arr.size();
  vector<int> newArr(len, 0);
  for (int i = 0; i < len; i++) {
    arr[i] = arr[i] * arr[i];
  }

  int newArrIdx = len - 1;
  int startPtr = 0;
  int endPtr = len - 1;

  while (startPtr <= endPtr && newArrIdx > -1) {
    if (arr[startPtr] < arr[endPtr]) {
      newArr[newArrIdx] = arr[endPtr];
      endPtr = endPtr - 1;
    } else {
      newArr[newArrIdx] = arr[startPtr];
      startPtr = startPtr + 1;
    }
    newArrIdx = newArrIdx - 1;
  }
  return newArr;
}

int main() {
  // initalize an array of accending integers

  vector<int> arr{-10, -8, -7, -7, -6, -4, -3, -1, 0, 4, 5, 6, 7, 8, 12, 19};

  // vector<int> newArr = sort_squared_slow(arr);
  vector<int> newArrFast = sort_squared(arr);

  for (int i = 0; i < newArrFast.size(); i++) {
    printf("%d ", newArrFast[i]);
  }
  printf("\n");
  return 0;
}

Installation

On MacOS, lldb is installed by default. On Linux, you can install it using the following command:

sudo apt install lldb

Usage

To debug a program, you can use the following command:

lldb <program>

This will open the lldb prompt. You can then use the following commands to debug your program:

• run: Run the program
• b <line_num>: Set a breakpoint at the specified line
• b <function_name>: Set a breakpoint at the specified function
• b 0x<address>: Set a breakpoint at the specified address
• b: List all breakpoints

There is also a gui mode that can be used by running the following command:

lldb <program>
b <function_name>
run
gui

Example

Let's say we have the following program:

#include <iostream>

int main() {
    int a = 1;
    int b = 2;
    int c = a + b;
    std::cout << c << std::endl;
    return 0;
}

Then make sure you complie it with the -g flag:

g++ -std=c++11 -g main.cpp

We can debug it using the following commands:

lldb a.out
b 5
run

This will set a breakpoint at line 5 and run the program. The program will stop at line 5 and we can use the following commands to inspect the variables:

• p a: Print the value of a
• p b: Print the value of b
• p c: Print the value of c
• n: Execute the next line
• s: Step into the next function call
• bt: Print the stack trace
• l: List the source code around the current line
• c: Continue execution until the next breakpoint
• q: Quit the debugger

References

• LLDB Tutorial
• LLDB Command Line Options

I say stop to it.

My current setup is as follows

I'll expand on my choices in later updates as I get more comfortable with them.

Other than that, this application has a new name now

It is "Track My Day"

The current page is deployed on https://trackmy.day. At the point of writing the page only has one h1 tag and one p tag.

I'm happy I got this domain.

Time tracking requires a lot of effort and discipline to get it right. What I want to do with this application is to try to remove the headache of tracking attention on various devices for a single individual and sync them in such a manner that, it stays true to the correct timeline of one's attention.

My main insight for this application is that, As much as I try to multitask my brain serializes all the tasks I throw at it.

One can always try to maximise the efficiency of the work that they're trying to accomplish by limiting the meaningful interactions seen by the brain.

And given the current tooling available there are two different problems I've faced

• You need to install different applications to track time on various different platforms which produce results which are incompatible to reconcile
• You need to start and stop time tracking manually most of the time

With this application I'm trying to bridge the gap between different platforms by

• passively recording app open and close
  • record "in app" tasks using extensions, which are easy to build using simple API to tag attention point correctly
• reconcile all the inputs from various platforms programatically
  • one solution I'm exploring right now is CRDT's
    • and it is looking promising

And my current goal is to make this work okayish for me. I'll try to update asap.

Till then stay classy.

I need to accomplish some tasks before I move on to proper deployment piepline for the rust backend

• Create a docker file that allows me to just start the container anywhere with some urls as environment variables
• To do that I need to copy litefs correctly into the docker container and run it
• To schedule database syncing before starting the application to enusre data consistency

As I'm reading more and more about this. I'm not sure if it's the right decision to run litefs.

The thing is that I don't know if its right to run while maintaining lighting speed during its production deployment.

Turns out you can't run write queries on replica databases which renders the whole use of litefs null and void.

Why even bother.. lol.

Read the following paragraph

Cluster management using leases

SQLite operates as a single-writer database which means only one transaction can write at a time. Because of this, we utilize a lease system whereby a single node acts as the "primary" node at any given time. All writes should be directed to that node and it will propagate changes to the rest of the cluster.

However, nodes can die or become disconnected from the cluster so the primary must be able to change dynamically. LiteFS is built to be run on ephemeral environments where cluster membership can change quickly and frequently so it utilizes leases via Consul to determine the current primary node.

When a LiteFS node starts up, it checks a key within the Consul server for the current primary node. If no primary node exists, then the LiteFS node attempts to obtain a lease from Consul to become a primary node itself. If successful, it updates the Consul key to share its API URL so other LiteFS nodes can connect to it.

Now With this cleared.. I need to look at alternatives for replacing litefs as my primary data store.

I can use a managed service for all my database needs and be done with it or I can look at other opensource services like following

VLCN or ayb

Exciting thing about VLCN is that it provides multi-master replication and partition tolerance to SQLite via conflict free replicated data types (CRDTs)

And ayb also provides simillar feature set but it is in its pre-alpha stage so not a good candidate for deployment right now.

Turns out planetscale allow writes on replicas but it's counted as a proper paid database which I'm not paying for an application that I haven't built yet.

Then there's turso and Cloudflare D1 which in turn are doing the same thing that I can do with LiteFS without the added cost of using an external service.

D1 fineprint

Larger databases: During the alpha period, the maximum per-database size is limited to 100 MB. We plan to support not only larger databases, but more databases, in the near future.

Read replication: D1 will create and distribute replicas of your data across the Cloudflare global network, reducing the latency for your read queries. Cloudflare distributes your data close to where your users are and keeps your read replicas up to date with changes.

Most probably will go ahead with litefs and come up with an working application by the end of this week.

Till then stay classy.

You end-up stringing multiple services to flow data from one point to another. And in then direct everything into a database.

DATABASES ARE DEAD. LONG LIVE THE DATABASE.

Why the f*** is everything on web? Why are we not allowed to struggle offline anymore? Do we even want that?

No, we want everything right here and right now. And web does that for them. And web is the perfect tool for that. Everything is possible on web, because there people making sure it feels that way.

But when I used dream about working on software I used to think my software will run on big servers doing very important stuff like computing maths related to black holes or something related to it.

But what I ended up doing is something horrible instead. I started working on web. Why does everything need to be a service? Why can't I just enjoy a piece of software and appreciate it's design.

I'll try to figure out what I'll do next. Till then stay classy.

Rather than blocking the main execution thread, async code gets pushed to the event queue that fires after all other code executes. It can, however, be difficult for beginners to follow async code. This article aims to clarify all of that.

Understanding Async Code

So the most basic example of asynchronous code in js are setTimout and setInterval. setTimout executes a function after a certain amount of time passes. It accepts a callback function and time(in milliseconds) as the second argument.

console.log('a')
setTimeout(function () {
  console.log('c')
}, 100)
setTimeout(function () {
  console.log('d')
}, 100)
setTimeout(function () {
  console.log('e')
}, 100)
console.log('b')

/* The output will be 
a
b
c
d
e
*/

Here we can see that the output matches our expectation.

The execution of code happened as following,

• on first line it blocking-ly executed console.log('a')
• then it saw an asynchronous function which it added to the event queue.
  • understand that it hasn't started executing the code yet, that will happen later.
• similarly it added second and third setTimeout to event queue.
• eventually it reached console.log('b') which it executed blocking-ly.
• and after all the code has been executed in the block. then only js engine starts executing the async code from event queue.

The event loop is a queue of callback functions. When an async function executes, the callback function is pushed into the queue. The javascript engine doesn't start processing the event loop until the code after an async function has executed. This allows us to see that our js code is not multi-threaded, even though it appears so.

The Event loop is a FIFO queue, meaning the callback function will execute in the order they were added onto the queue. And using node allows us to use this asynchronous behavior on the backend as well.

Various ways to use async code execution

• Callbacks
  • Named function [passing functions as variables]
  • Promises [dependent on callbacks]
• Events

Callbacks

This is the main method any async code is executed. Async programming lends itself to what's commonly referred to as "callback hell". Because virtually all async functions in JavaScript use callbacks, performing multiple sequential async functions result in many nested callbacks--resulting in hard to read code.

const fs = require('fs')

fs.exists('index.js', function () {
  fs.readFile('index.js', 'utf8', function (err, contents) {
    contents = someFunction(contents) // do something with contents
    fs.writeFile('index.js', 'utf8', function () {
      console.log('whew! Done finally...')
    })
  })
})
console.log('executing...')

Nested callbacks can get really nasty, but there are several solutions to this style of coding.

Named functions

An easy solution that cleans nested callbacks is simply avoiding nesting more than two levels. Instead of passing anonymous functions to the callback arguments, pass a named function, which is a feature that javascript provides us.

var fromLatLng, toLatLng

// And lastly this function will execute
var routeDone = function (e) {
  console.log("ANNNND FINALLY here's the directions...")
  // do something with e
}

// Secondly this function will execute
var toAddressDone = function (results, status) {
  if (status == 'OK') {
    toLatLng = results[0].geometry.location
    map.getRoutes({
      origin: [fromLatLng.lat(), fromLatLng.lng()],
      destination: [toLatLng.lat(), toLatLng.lng()],
      travelMode: 'driving',
      unitSystem: 'imperial',
      callback: routeDone,
    })
  }
}

// First this function will execute
var fromAddressDone = function (results, status) {
  if (status == 'OK') {
    fromLatLng = results[0].geometry.location
    GMaps.geocode({
      address: toAddress,
      callback: toAddressDone,
    })
  }
}

// Initializing function
GMaps.geocode({
  address: fromAddress, // address object is defined globally
  callback: fromAddressDone,
})

Promises

While using named functions is a neat concept that is widely used, but keeping track of named function variables can get quite daunting, quite fast.

And there's no guarantee that those variables can't be overridden by other parts of our program.

For this reason and where we are sure about the flow of the data. We can use promises, which allows us to chain functions to achieve a desired state in our application.

Let's look at how we can initialize a promise

let promise = new Promise(function (resolve, reject) {
  // the executor function is executed
  // automatically when the promise is constructed

  // after 1 second signal that the job is
  // done with the result "done"
  setTimeout(() => resolve('done'), 1000)
})

Consumers

Now the part where we chain the consumer functions A Promise object serves as a link between the executor (the “producing code”) and the consuming functions, which will receive the result or error. Consuming functions can be registered (subscribed) using methods .then, .catch and .finally.

then

The most important, fundamental one is .then.

promise.then(
  function (result) {
    /* handle a successful result */
  },
  function (error) {
    /* handle an error */
  }
)

The first argument of .then is a function that runs when the promise is resolved, and receives the result.

The second argument of .then is a function that runs when the promise is rejected, and receives the error.

catch

If we’re interested only in errors, then we can use null as the first argument: .then(null, errorHandlingFunction). Or we can use .catch(errorHandlingFunction), which is exactly the same:

let promise = new Promise((resolve, reject) => {
  setTimeout(() => reject(new Error('Whoops!')), 1000)
})

// .catch(f) is the same as promise.then(null, f)
promise.catch(alert) // shows "Error: Whoops!" after 1 second

The call .catch(f) is a complete analog of .then(null, f), it’s just a shorthand.

finally

Just like there’s a finally clause in a regular try {...} catch {...}, there’s finally in promises.

The call .finally(f) is similar to .then(f, f) in the sense that f always runs when the promise is settled: be it resolve or reject.

finally is a good handler for performing cleanup, e.g. stopping our loading indicators, as they are not needed anymore, no matter what the outcome is.

Like this:

new Promise((resolve, reject) => {
  /* do something that takes time, and then call resolve/reject */
})
  // runs when the promise is settled
  // doesn't matter successfully or not
  .finally(() => stop loading indicator)
  // so the loading indicator is always
  // stopped before we process the result/error
  .then(result => show result, err => show error)

That said, finally(f) isn’t exactly an alias of then(f,f) though. There are few subtle differences:

1. A finally handler has no arguments. In finally we don’t know whether the promise is successful or not. That’s all right, as our task is usually to perform “general” finalizing procedures.

2. A finally handler passes through results and errors to the next handler.

   For instance, here the result is passed through finally to then:

new Promise((resolve, reject) => {
  setTimeout(() => resolve('result'), 2000)
})
  .finally(() => alert('Promise ready'))
  .then((result) => alert(result)) // <-- .then handles the result

And here there’s an error in the promise, passed through finally to catch:

new Promise((resolve, reject) => {
  throw new Error('error')
})
  .finally(() => alert('Promise ready'))
  .catch((err) => alert(err)) // <-- .catch handles the error object

That’s very convenient, because finally is not meant to process a promise result. So it passes it through.

Events

Events are another solution to communicate when async callbacks finish executing. An object can become an emitter and publish events that other objects can listen for. This type of eventing is called the observer pattern.

The Event Loop is a queue of callback functions.

Browser JavaScript execution flow, as well as in Node.js, is based on an event loop.

Understanding how event loop works is important for optimizations, and sometimes for the right architecture.

In this chapter we first cover theoretical details about how things work, and then see practical applications of that knowledge.

Event Loop

The event loop concept is very simple. There’s an endless loop, where the JavaScript engine waits for tasks, executes them and then sleeps, waiting for more tasks.

The general algorithm of the engine:

1. While there are tasks:
   • execute them, starting with the oldest task.
2. Sleep until a task appears, then go to 1.

That’s a formalization for what we see when browsing a page. The JavaScript engine does nothing most of the time, it only runs if a script/handler/event activates.

Examples of tasks:

• When an external script <script src="..."> loads, the task is to execute it.
• When a user moves their mouse, the task is to dispatch mousemove event and execute handlers.
• When the time is due for a scheduled setTimeout, the task is to run its callback.
• …and so on.

Tasks are set – the engine handles them – then waits for more tasks (while sleeping and consuming close to zero CPU).

It may happen that a task comes while the engine is busy, then it’s enqueued.

The tasks form a queue, so-called “macrotask queue” (v8 term):

For instance, while the engine is busy executing a script, a user may move their mouse causing mousemove, and setTimeout may be due and so on, these tasks form a queue, as illustrated on the picture above.

Tasks from the queue are processed on “first come – first served” basis. When the engine browser is done with the script, it handles mousemove event, then setTimeout handler, and so on.

So far, quite simple, right?

Two more details:

1. Rendering never happens while the engine executes a task. It doesn't matter if the task takes a long time. Changes to the DOM are painted only after the task is complete.
2. If a task takes too long, the browser can’t do other tasks, such as processing user events. So after a time, it raises an alert like “Page Unresponsive”, suggesting killing the task with the whole page. That happens when there are a lot of complex calculations or a programming error leading to an infinite loop.

Microtasks

Along with macrotasks, described in this chapter, there are microtasks, mentioned in the chapter Microtasks.

Microtasks come solely from our code. They are usually created by promises: an execution of .then/catch/finally handler becomes a microtask. Microtasks are used “under the cover” of await as well, as it’s another form of promise handling.

There’s also a special function queueMicrotask(func) that queues func for execution in the microtask queue.

Immediately after every macrotask, the engine executes all tasks from microtask queue, prior to running any other macrotasks or rendering or anything else.

For instance, take a look:

setTimeout(() => alert('timeout'))

Promise.resolve().then(() => alert('promise'))

alert('code')

What’s going to be the order here?

1. code shows first, because it’s a regular synchronous call.
2. promise shows second, because .then passes through the microtask queue, and runs after the current code.
3. timeout shows last, because it’s a macrotask.

The richer event loop picture looks like this (order is from top to bottom, that is: the script first, then microtasks, rendering and so on):

All microtasks are completed before any other event handling or rendering or any other macrotask takes place.

That’s important, as it guarantees that the application environment is basically the same (no mouse coordinate changes, no new network data, etc) between microtasks.

If we’d like to execute a function asynchronously (after the current code), but before changes are rendered or new events handled, we can schedule it with queueMicrotask.

Summary

A more detailed event loop algorithm (though still simplified compared to the specification):

1. Dequeue and run the oldest task from the macrotask queue (e.g. “script”).
2. Execute all microtasks:
   • While the microtask queue is not empty:
     • Dequeue and run the oldest microtask.
3. Render changes if any.
4. If the macrotask queue is empty, wait till a macrotask appears.
5. Go to step 1.

To schedule a new macrotask:

• Use zero delayed setTimeout(f).

That may be used to split a big calculation-heavy task into pieces, for the browser to be able to react to user events and show progress between them.

Also, used in event handlers to schedule an action after the event is fully handled (bubbling done).

To schedule a new microtask

• Use queueMicrotask(f).
• Also promise handlers go through the microtask queue.

There’s no UI or network event handling between microtasks: they run immediately one after another.

So one may want to queueMicrotask to execute a function asynchronously, but within the environment state.

In most Javascript engines, including browsers and Node.js, the concept of microtasks is closely tied with the “event loop” and “macrotasks”. As these have no direct relation to promises, they are covered in another part of the tutorial, in the article Event loop: microtasks and macrotasks.

References

• Microtasks
• MicroTasks
• Async in JS
• Book to read
• HTML Spec
• Understanding Execution

• UTF-8 grapheme clusters.
• Ownership and lifetimes.
• Closures

The concepts above are new to me. And I really had fun learning them. To be honest I found rust much better than Dart and Swift. And I don't think I'll let go of this language anytime soon.

Also I've ditched the whole Nuxt.js bandwagon. It was fine, but I really didn't needed it. Now the whole website is static. Just like it should've be from the beginning.

Anyway I have COVID. I've lost taste and smell. Rest everything is fine.

Till then, take care.

• Books
• Application Projects
• New Languages
• New Frameworks

Books

So the number of books is not huge for any well read individual, but the problem is I'm try to read all of them at once, and that's mixing up storylines, ideas and key takeaways.. Currently I'm reading:

• Triggers: Creating Behavior That Lasts - Marshall Goldsmith
• The F*ck It Diet: Eating should be easy - Caroline Dooner
• Art of Captivating conversation - Patrick King
• The Prince of Milk - exurb1a
• Cracking the Coding Interview - Gayle Laakmann McDowell

And I listening to:

• Deep Work - Cal Newport [3rd Time]
• The Optimist's Telescope - Bina Venkataraman

Application Projects

I currently have 11 ongoing projects, including this blog; four of those are full size projects with their separate trello boards to keep track of all the bullshit I do with them on regular basis.

And all of them take too much time to develop. One thing I do regularly is ask a simple question which derails all the work I've done till now a and I start writing the whole application again is that, "What new languages, frameworks are available right now in the market?" This brings us to the next section..

New Languages

I'm currently trying to learn..

• Rust - personal reasons
• Dart - personal reasons
• Swift Don't ask how but these have just taken over my life currently.

New Frameworks

The reason, from my understanding, why I have picked up so many frameworks at once is that I have so many projects that have different need that can only be fulfilled by combination of these frameworks..

• TailwindCSS
• BulmaCSS
• Flutter
• Tokio : Rust
• Vite (Vue 3)
• Nuxt.JS (Vue 2)
• Kubernetes [with all the supporting stack]
• Material-UI (React)

And I need time to process and internalize all of this information while I also listen to podcasts, youtube videos, etc. Tbh I'm burnt out.

In the moment all of this feels important and no sh*t IT IS. I've tried all the ways under the sun where I can manage all of these at once, but I think I've already hit a limit of my brain and no tool can help me with that.

And all of this happens after all the work I do at my job.. which is way more streamlined than this but it's still big.. At work currently I'm trying to integrate the payment systems for Stripe, Android InApp Purchases and iOS InApp Purchases, Both Backend and Frontend (React, Android, iOS, Node).

You can only do so much at a time.

Triage is important and should be done, but rarely and carefully otherwise the cost of complacency is huge. I can explain why I've decided to limit myself to work stuff and the following things:

• Youtube Music
• Cracking the Coding Interview - Gayle Laakmann McDowell
• Flutter But I won't. Ask me if you're curious.

Rest everything is shelved now. I'll pick them up later on.

So it all started with the two greatest chums who seem to have touched every topic on earth, Plato and Aristotle.

It was 387 BC and Plato was chilling in Akademia[The academy founded by Plato. Platonic Academy]. He was going about his day messing with his students and philosophers after 2000 years from his time, a bloke came to him and asks him a simple question "What are numbers", he got up and then went inside and started having a lukewarm mental breakdown.

After some time he comes out of the Akademia with The Philosophy of Mathematics.

His philosophy basically said. "There are objects and there are forms. And numbers and the relations between them (like addition and stuff) are independent of us and objects of the real world and are in turn objects of world of forms. And we just relate to those objects from world of forms cause they allow us to define our world."

Plato was happy about his explanation, but there was one guy who took that definition not well to his heart, that was his star student Aristotle. Aristotle said there no other world than this, that old man is clearly out of his mind. I can't really tell.

So now he went inside Akademia and had his own version of mental breakdown.

Having mental breakdowns was cool back then - Diogenes.

So he comes out with his own theory about numbers. It goes something like this..

"There are objects in the world and objects have properties and one of the property of the object is a number attached to it. If you see a cube the number of surfaces is the property of the object." - this is what he said in a really broad sense.

And then both of them forgot about this little topic and went on to f@%k with the rest of philosophical society for lulz.

Fast forward to 1870's. Time was wild. First headphone jack was invented, by the way that design is still used to this day. Edison created a light thingy. Bell created phone. Fashion was shit.

In Germany there was a guy named Gottlob Frege. And he was pissed. He was not happy about how Plato and Aristotle did not do their job properly and never reached a conclusion regarding the deal about numbers.

To be honest he just got stuck with the words "Some" and "All", like a dedicated math freak after getting some good kush. He raised questions about the definition that Aristotle gave out. "Numbers being properties of an object".

He said, "If numbers were the properties of object then A single (1) bouquet and A group 25 of flowers shouldn't be the same thing. And if in-fact they are same, then an object should be having multiple ''number properties' attached to it and that doesn't make any sense."

He then went ahead and proposed his own idea about what numbers are. He said - "Numbers are extensions to a concept. And a concept can be anything you want."

• all the cats you know

• all the cats you don't know

• all the dogs you know

• all the dogs you don't know

• wheels in your house

• rats in your house

• all the yellow birds in Amazon forest

• etc..

So once you define a concept you can just go ahead and assign a number to that concept. And that number can be zero/infinity, whatever you want.

He was damm pleased with his explanations. And was about get them published. But then, an ultimate savage from Britain[Bertrand Russell The ultimate savage.] wrote Frege a letter. Stating that - "He loves his work and everything he formulated till now is wonderful, but there is one point Frege missed."

Okay this is little tricky, But bear with me on this one..

"Let us call a set 'Normal' if it is not a member of itself, and 'Abnormal' if it is a member of itself."

Simple? Read it again if it's not settled in your brain.

Now consider a Variable R and assume it is a set of all the 'Normal' sets.

Nothing wrong there? now determine whether R is normal or abnormal.

There are two scenarios, R is normal or R is abnormal.

If R is normal then R would contain itself since that's how we defined R - [set of all normal sets] and that would make R abnormal cause that's how we defined 'abnormal'.

And if R is abnormal then R would would be a member of a set whose members are normal cause that's how we defined R.

Thus R is neither normal or abnormal. It's just there to mess with your brain.

This paradox literally caused him to go to hospital. You can search for Barber's paradox for similar kind of reasoning.

Later on we move away from Ferge's theory to Zermelo–Fraenkel set theory. This theory is built in a way, that it just avoids this paradox. And there are contenders to this theory as well[Criticisms]. So let's see what happens in future.

PS: I learned about this paradox from Jades Video. I would highly suggest you to go and watch her. As she explains this in much more detail and much more effortlessly.

In this sort of informal story I took many artistic licences and made up a lot of stuff. Do come and shout on me at twitter if I made any mistake.

To be honest I've struggled with this a lot. I've had so many problems with this method

• You essentially write down everything that was spoken to you and try to keep up with the teachers ability to read his/her notes. Do try if you're feeling adventurous.
• The notes you make during your childhood were never meant to be used by the adult you. I find that really frustrating. I mean if by making notes, we are organizing facts and ideas in a way to be used later by the future self, why not make those notes useful for the rest of one's life.
• Whenever we come across a new PRIMARY SOURCE, we tend to ignore it completely and try to search for some ways where we can find the condensed information regarding that PRIMARY SOURCE, like a guide or summary.
• And there is little to no way to tell if there has been a update regarding a topic, if the PRIMARY SOURCE was first published in 1863. NO GOES AROUND SEARCHING FOR FOLLOW-UPS. It should be available with the PRIMARY SOURCE linked with it as [Updates].

For the last 3-4 months I've been researching on the ways I can organize my thoughts and findings. I've already looked at the following

• Have folders within folders to organize hierarchical data.
• Have lots of files with the ability to search.
• Have small index card which essentially have atomic information.
• Or have tags.

Tags have a special ability to link multiple facts and ideas, in a very simple and easy way. Whenever you find/produce a new piece of information, you just need to tag it.

Whether be it a link to a video or a long piece of article you wrote. You can find both of them later on super easily just by looking at a common tag. And these pieces of information can be found somewhere else also if more tags are attached to them.

And to give you some background, the use of tags predates computer storage. Paper data storage devices, notably edge-notched cards, that permitted classification and sorting by multiple criteria were already in use prior to the twentieth century, and faceted classification has been used by libraries since the 1930s.

I've come to terms with the fact that the fastest and easiest way to organize information is by using Zettelkasten and tags.

Both the ideas compliment each other so much that I instantly fell in love with it.

For the uninitiated, Zettelkasten is the method of recording information in its atomic form, and linking those bits of information to create whole topic. This way all the complex topics in this world can be boiled down to basic bits of information. And you link those bits of information with direct links and tags. A good resource for learning more about zettelkasten, is here.

One can argue that having a global fuzzy search might yield the same result. I agree you might be able to find the specific information/knowledge with a global search but tags offer you much more than that, tags bring networked knowledge to the table.

You can look at a tag and multiple data points come with their own tags and you can then follow them to find insights which you might not have been able to figure out if you just used search.

I still need to research how should one organize tags. Should one use hierarchy to organize them or just organize them alphabetically?

I want to implement tagging for my blog also, it would be fun, I think.

Stay at home. Stay safe.

So this one took a long time to figure out. And I went so many places to find a fix this one. To be honest I wasn't looking that text/htmlmuch.

I'll spare you all the hacks I did. Turns out the solution was dead easy.

Steps

• First open your nuxt.config.[js|ts] and specify the fallback page there

  export default {
    // Other Stuff
    generate: {
      fallback: '404.html',
    },
  }
  

• Run npm run generate to generate all the static files, it will generate the dist folder.

• Copy the dist folder to the root of your site.

• Then go to your nginx config and tell it to serve this specific 404 page, assuming that the root of the server has all the files from dist.

  server {
  # routes and certificates
    error_page 404 /404.html;
  }
  

So I've created a new blog. And it's made using tech and standards I love, namely:

• Vue.js (Nuxt.js)
• Markdown
• Plain old HTML CSS

I have some ideas that I would like to implement to the blog. Like having a way to categorize on the basis of tags, dates and authors.

The thing I am most happy about is the dark theme switcher. If you would have noticed, the blog automatically picked up your devices preference of dark mode and applied it.

Pretty cool if you ask me.

Anyways, I'm planning to write posts on software development, politics and bunch of other stuff. And that's the reason I need tags.

I'll also expand upon how tags are different from categories and how you can utilize them most efficiently.

Till then, take care.