In this article, we’ll walk through the major CLI tools available, explain how they work under the hood, and highlight when you should use each.

We’ll cover:

1. SSH (Secure Shell) Tools

   1.1 SCP (Secure Copy)

   1.2 SFTP (SSH File Transfer Protocol)

   1.3 SSHFS (SSH Filesystem Mount)

2. Rsync

3. HTTP(S) + Download Accelerators

   3.1 HTTP Single-thread server (Python)

   3.2 HTTP Multi-thread server (BusyBox httpd)

   3.2.1 Download Accelerators (aria2c, axel)

   3.3 HTTPS File Server with Basic Auth (Caddy)

1. SSH (Secure Shell) Tools

These tools leverage the established Secure Shell (SSH) protocol for secure, encrypted transfers and operations.

1.1 SCP (Secure Copy)

SCP is the classic method for transferring files over SSH. It opens a secure channel, encrypts data, and performs a raw byte stream transfer.

# Upload a file
scp local_file user@remote:/path/to/destination

# Download a file
scp user@remote:/path/to/file local_dir/

# Copy between two remote SSH hosts
scp user1@remote1:/file user2@remote2:/destination

✅ Advantages:

• Installed by default on nearly all systems.

• Simple syntax for quick transfers.

• Can copy files directly between two remote SSH servers.

❌ Drawbacks:

• No resumability; interrupted transfers start from scratch.

💙 Best Use Case:

• scp is best for one-off, quick, and secure transfers where you don’t expect interruptions.

1.2 SFTP (SSH File Transfer Protocol)

SFTP is more feature-rich than SCP. It supports interactive sessions, directory traversal, file operations, and resumable transfers (when the client supports the feature).

# Interactive session
sftp user@remote
sftp> get -a remote_file local_file  # -a for resume/continue or use reget instead.
sftp> put local_file remote_file

# One-liner download
sftp user@remote:/path/to/file local_file

✅ Advantages:

• Resumable transfers with most clients (using -a or reget).

• Interactive mode for browsing and transferring.

• Compatible with GUI clients like FileZilla and WinSCP.

❌ Drawbacks:

• Slightly slower than SCP due to protocol overhead.

• Cannot transfer between two remote servers.

💙 Best Use Case:

• Since sftp is a maintained SSH session, it is useful when there are a lot of small file transfers, and the folder structure is unknown.

1.3 SSHFS (SSH Filesystem Mount)

SSHFS mounts a remote filesystem locally using SSH and FUSE (Filesystem in Userspace). This allows you to use your existing tools and editors as if the files were on your machine.

# Mount remote filesystem
sshfs user@remote:/remote/path /local/mountpoint

# Unmount
fusermount -u /local/mountpoint

✅ Advantages:

• Transparent: Edit remote files with your local IDE/editor seamlessly.

• Secure by default via SSH.

• Great for exploratory work or ad-hoc editing.

❌ Drawbacks:

• High latency on every file operation (slow for reading many small files).

• Poor throughput for large files or bulk transfers.

• Requires sshfs and FUSE support.

💙 Best Use Case:

• sshfs is ideal for development workflows where convenience and direct file access matter more than transfer speed.

2. Rsync

Rsync is optimized for synchronization and efficiency. Instead of re-copying everything, it calculates file checksums and only sends the differences (deltas). This delta-transfer algorithm, along with built-in compression and partial transfers, makes it a synchronization powerhouse.

# Sync local directory to remote (Archive, Verbose, Compress and Partial Transfer)
rsync -avzP local_dir/ user@remote:/path/to/dir

✅ Advantages:

• Extremely efficient for repeated transfers (only sends deltas).

• Built-in compression (-z) and resumability.

• Preserves permissions, symlinks, and timestamps.

❌ Drawbacks:

• Requires rsync on both machines.

• More CPU-intensive due to checksum calculations.

💙 Best Use Case:

• rsync is the go-to tool when you’re syncing directories with frequent updates or working with limited bandwidth where sending only changes matters most.

Performance Note: For initial full transfers, rsync overhead (checksum calculations) makes it slightly slower than raw HTTP transfers. However, for incremental syncs with only changed files, rsync is dramatically faster since it only transfers deltas.

3. HTTP(S) + Download Accelerators

These methods prioritize raw speed by leveraging the lightweight nature of HTTP and the ability of clients to open parallel connections and partial downloads.

3.1 HTTP Single-thread server (Python)

Python's built-in HTTP server is the quickest way to share files. It serves the current directory over HTTP with zero configuration.

# Server
python3 -m http.server 8000

# Client
wget http://<server-public-ip>:8000/filename.ext

✅ Advantages:

• Works out of the box.

• Faster than any of the SSH Tools, No SSH encryption/protocol overhead.

❌ Drawbacks:

• Single-threaded -> only one client at a time.

• No authentication.

• An SSH connection or a background job is required.

• One-way setup (server -> client).

💙 Best Use Case:

• Transferring non-sensitive medium-sized files on a trusted local network for quick testing.

3.2 HTTP Multi-thread server (BusyBox httpd)

BusyBox's httpd is a lightweight, multi-threaded HTTP server that handles multiple concurrent connections, making it ideal for serving files to several clients simultaneously.

# Server
busybox httpd -f -p 8000

# Client
wget http://<server-public-ip>:8000/filename.ext

# download-accelerators http://<server-public-ip>:8000/filename.ext

✅ Advantages:

• Works out of the box.

• No SSH encryption overhead.

• Handles concurrent connections and multiple clients.

❌ Drawbacks:

• No authentication.

• An SSH connection or a background job is required.

• One-way setup (server -> client).

💙 Best Use Case:

• Transferring non-sensitive large-sized files on a trusted local network for quick testing.

3.2.1 Download Accelerators (aria2c, axel)

Download accelerators are client-side tools that work with any HTTP/HTTPS server. They split downloads into multiple parallel streams, saturating your available bandwidth for maximum speed. These tools can be used with busybox httpd (3.3), or Caddy (3.4).

• aria2c: multi-source, segmented downloads, resumable (-c).

• axel: lightweight, parallel streams, resumable, simpler than aria2c.

# busybox httpd (HTTP) (3.2)
aria2c -c -x 8 -j 8 http://<server-public-ip>:8000/filename.ext

axel -n 8 http://<server-public-ip>:8000/filename.ext

# Caddy (HTTPS) (3.3)
aria2c -c -x 8 -j 8 --http-user=<username> --http-passwd=<password> --check-certificate=false https://<server-public-ip>/filename.ext

axel -n 8 -k -H "Authorization: Basic $(printf '<username>:<password>' | base64)" https://<server-public-ip>/filename.ext

✅ Advantages:

• Parallel streams saturate bandwidth.

• Built-in resume support.

❌ Drawbacks:

• Requires installation on client.

• Background server process needed.

3.4 HTTPS File Server with Basic Auth (Caddy)

A multi-threaded HTTP server is fast, but it is not secure. The final solution to file transferring is to go into overdrive mode and use a production server. Here, we are using Caddy for simplicity; we could have used NGINX and CertBot to accomplish the same.

# Server
caddy hash-password --plaintext <password>
# $2a$14$moXJYUFKt1w6d...
cat Caddyfile

https://localhost, https://127.0.0.1,  https://<server-public-ip> {
     tls internal

     root * /path/to/local_dir
     file_server browse

     basicauth {
         <username>  $2a$14$moXJYUFKt1w6d...
     }
}

sudo caddy run --config /path/to/Caddyfile

Security Note: The example below uses --check-certificate=false because tls internal in Caddy creates a self-signed certificate. In production, use proper certificates with Let's Encrypt (for public IPs with domain names) or an internal Certificate Authority.

# Client

# aria2c
aria2c -c -x 8 --http-user=<username> --http-passwd=<password> --check-certificate=false https://<server-public-ip>/filename.ext

# axel
axel -n 8 -k -H "Authorization: Basic $(printf '<username>:<password>' | base64)" https://<server-public-ip>/filename.ext

✅ Advantages:

• Authentication and encryption built-in.

• Supports parallel downloads.

❌ Drawbacks:

• More complex setup.

• One-way setup (server -> client).

💙 Best Use Case:

• Sharing link for large files over the internet (with auth).

Security Considerations

Understanding the security implications of each tool is critical when choosing a file transfer method:

SSH-Based Tools (SCP, SFTP, SSHFS, Rsync over SSH)

• Encrypted by default using SSH protocol

• Uses public key authentication (SSH keys) or password authentication

• Suitable for transferring sensitive data over untrusted networks

• Requires SSH access and proper key management

HTTP Servers (Python, busybox)

• No encryption - data transferred in plain text

• No authentication - anyone with network access can download files

• Use only on trusted local networks (VPNs, private subnets)

• Never use for sensitive data without additional security measures

HTTPS (Caddy)

• Encrypted via TLS

• Basic Authentication sends credentials with every request

• Self-signed certificates (using tls internal) trigger security warnings and require --check-certificate=false

• For production use, obtain proper certificates via Let's Encrypt or internal CA

• Suitable for transferring files over public networks when configured correctly

Best Practice:

• Use SSH-based tools for sensitive data over untrusted networks.

• HTTP servers are perfectly acceptable on trusted networks (VPNs, private subnets) where the network layer already provides security.

• Use HTTPS only when transferring files over public internet without VPN protection.

Performance Comparison: Slowest to Fastest

1. SSHFS: High latency per operation, every read/write is a round-trip over SSH.

2. SCP/SFTP: SSH encryption overhead, single-threaded.

3. Rsync over ssh: Efficient delta transfers and compression.

4. HTTP Single-Threaded: Direct HTTP with no encryption overhead.

5. HTTPS Multi-Threaded + Download Accelerators: Parallel streams that saturate available bandwidth. HTTPS adds ~10-20% overhead.

My Daily Workflow

Here is what I use on a day-to-day basis:

• scp: When transferring small files between VMs (and when I forgot rsync flags.)

• sftp: When I have many small files to operate on, and I also don't know the directory structure, the command has fewer flags and is easier on fingers.

• sshfs: Never used.

• rsync over ssh: I have majorly replaced scp with rsync -aivP (I don't use compression on the fly). It is especially handy with large files.

• python3 -m http.server 8000: Not anymore for my setup, but I am debugging someone else's setup, then they probably don't have download accelerators.

• busybox httpd -f -p 8000: Since most file transfer work happens over VPN with private endpoints. So for large files, this is my go-to choice.

• HTTPS File Server (Caddy): Sending public links (outside VPN but still with user and password) for file download.

Each tool addresses the same problem differently. By understanding their trade-offs, you can pick the right tool for your specific requirements instead of defaulting to SCP.

⚡ Usage:

$ alias-alchemy.ra101.dev/?q=py,shell,k8s > .aliases.sh
$ cat .aliases.sh

# Python Aliases (py, py(uv), alembic, django, celery)
...

# Shell Aliases (debian, git)
...

# Kubernetes Aliases (kubectl, kubecolor, kustomize)
...

🤔 Why I built it ?

1. I constantly create new VMs at my job, and the very first command I run usually fails because it was an alias typed by pure muscle memory. Once you start using aliases, it is hard to write full commands, especially those Kubernetes aliases.

2. Whenever I start a new language, I start building aliases. For example, while learning Java (+ Maven), I made: alias jexec = "mvn exec:java -Dexec.args=$@". Since there’s no standard alias collection for most tools, I created Alias Alchemy to be that open-source standard — a handy tool for whenever someone starts something new.

3. I wanted to learn Deno, and this is my "hello-world" project.

📖 Help Guide:

Enough Stories ! Let’s look at the help guide !

The current version supports the following

$ curl -L alal.deno.dev/help

Alias Alchemy - The best way to download aliases for fast setup.

USAGE:
    curl -L "alias-alchemy.ra101.dev/?q=<category-1>,<category-2>,..."

AVAILABLE CATEGORIES:
    , (null)                   All aliases
    shell, sh                  Shell aliases (Debian, Git, utilities)
    python, py                 Python aliases (py, py(uv), alembic, django, celery)
    docker, dk                 Docker aliases (docker, compose, swarm)
    podman, pd                 Podman aliases (podman, compose)
    kubernetes, k              Kubernetes aliases (kubectl, kubecolor, kustomize)

SHORT DOMAIN:
    alal.deno.dev

SUPPORTED TOOLS:
    curl, wget, httpie, aria2, postman, or any tool with User-Agent: 'alal'

For more information, visit: https://alias-alchemy.ra101.dev

Links:

• Website: https://alias-alchemy.ra101.dev

• Github Repo: https://github.com/ra101/alias-alchemy

What are AI hallucinations?
AI hallucinations are incorrect or misleading results that AI models generate.

Story Time
I was looking for "colour quantization algorithms" for a project (I put these words together in my brain and it was an actual thing!). As the name suggests, I wanted to reduce the number of distinct colours in an image. Anyway, I googled it and all the answers were about the K-means clustering algorithm.

Now, this algorithm is quite slow for my use case, So I went to chatGPT for the same, I spit out 5 different algorithms and out of them I selected the "Median Cut" algorithm and asked to write a code in Python, It returned a code using Pillow Library, I asked to re-write the code in using OpenCV and numpy, and it returned another piece of code.

These 2 codes had slightly different implementations. None of them ran in the first go, but after some refactoring, they both yielded results! Different Results!

Okay, I already had the Algo's name, so I googled "median cut algorithm python" and I found a Github link, 2nd result. This code had different implementations! I can easily find papers and read articles about this algorithm and my issue will be resolved.

That's where the paranoia began!
What if this code is AI-generated? It is a 5-year-old code, so probably isn't. But 5 years down the line, Github will be full of mediocre code, full of misunderstood concepts. I see new junior engineers using ChatGPT daily to write small components of code. If there is some dumb code, PR reviewers will catch them. But After 7 years they will be managers and PR reviewers. What then?

Today, every undergrad uses ChatGPT for his/her thesis. Heck, If I had access to it, I would have used it too. When these undergrads will do their PhD, will they use ChatGPT? Yes. From generating topics to writing abstracts and conclusions, even bibliographies, GPT can do it all.

What about checking these papers? One can certainly make AI that could check these. Even if there was a law, that human review is required for any scientific report or article. A Lazy-Smart person will try and automate it. Guess what they would use? AI or Maths?

We can just hope that any hallucinated or out-of-context/sarcastic reference which is interpreted as useful by Students' AI is caught with Teachers' AI.

BTW, This is what ChatGTP 3.5 has to say about it:

> AI Hallucinations will lead to a mediocre future

While AI hallucinations can be intriguing from a research perspective, they don't necessarily imply a "mediocre future" In fact, AI holds immense potential to revolutionize various fields, from healthcare to transportation, and from education to entertainment.

AI being biased about AI is probably not ideal, I want my AI to be an insecure nerd (like me), not a confident politician/cult leader.

Conclusion
With the invention of the Pen, We gained so much but We lost the power of memorization. With AI, rapid development is imminent, But I feel the loss will be far too much.

We lost our muscles and survival instincts when we left the caves. Heck, Without a flint stone, It would take me ages to light a fire in camp. With mediocre code and misunderstood whitepapers, It seems the time for our brains to regress/halt has come.

What Next?
What Next? Nothing mate! Even with all this said, AI will not stop, Skynet is inevitable. Let me give you a taste of what I feel, Ask yourself a simple question, Who wrote this article?

What is Git Squash-Rebase Workflow?

Git Squash Rebase is a workflow in which:

• multiple commits are squashed into a single cohesive commit,

• then rebased from the up-to-date main branch.

This results in a cleaner commit history, grouping of changes, easier code reviews, and streamlined collaboration. Of-course there are some drawbacks of this workflow, but that is beyond the scope of this post.

Git Squash (gsq):

gsq(){
    # Usage:
    ## gsq -b "base_branch_opt" -n "squash_count_opt" -m "msg" -d "desc" -D
    ##
    ##    -b: Base Branch Name (default: default origin branch)
    ##    -n: Squash Count (default: all until base branch)
    ##    -m: Commit Message, (default: latest commit message)
    ##        - Uses Auto Commit Command, if present.
    ##    -d: Commit Description, (default: null)
    ##    -D: if passed, the description is populated with all the previous commit msg and desc until sqaush_count

    # Get Base Branch -> Get Fork Point -> Get Squashable Count -> Squash!

    ## Even though this command seems big, but the flow is pretty simple.
    ## I use a very lite version of this code, there is alot of validation and
    ## edges cases here, which is not particularly I care about in my personal use.

    # Declare Local Var
    local base_branch_opt; local squash_count_opt; local commit_msg_opt;
    local commit_desc_opt; local add_full_desc_opt=false;

    # Get Optional Arguments!

    ## Reset the getopts state
    OPTIND=1
    ## Parse Through new opts.
    while getopts b:n:m:d:D flag
    do
        case "${flag}" in
            b) base_branch_opt=${OPTARG};;
            n) squash_count_opt=${OPTARG};;
            m) commit_msg_opt=${OPTARG};;
            d) commit_desc_opt=${OPTARG};;
            D) add_full_desc_opt=true;;
        esac
    done

    # Get Base Branch
    # ----------------

    ## Update base_branch_opt with default origin branch, if not passed!
    local current_branch=$(git rev-parse --abbrev-ref HEAD)
    if [[ $base_branch_opt == "" ]]; then
        base_branch_opt=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')
    fi

    # Get Fork Point Commit
    # ----------------

    # Check if given base branch is actually an ancestor or not.
    local fork_point_commit=""
    if [[ $( git branch --merged HEAD 2> /dev/null | sed  -e 's/* \(.*\)/ \1/' -e  's/^ *//g' | grep -w "$base_branch_opt" ) != "" ]]; then
        ### Get the Last commit by `base_branch_opt`
        fork_point_commit=$(git merge-base --fork-point "$base_branch_opt")
    else
        ### Throw Error if Base Branch is not found as an ancestor.
        echo "Invalid Base Branch! " && return 1
    fi

    # Get Squashable Count
    # ----------------
    ## Exit, if Squashable Count is 0!
    ## We are okay with squashing 1 commit, the reason for that is, this allows us
    ## to stage the changes and use `gsq` to commit those changes into squashed commit


    ## squashable_count: Number of commits that can be to be squashed
    local current_commit=$(git rev-parse HEAD)
    local squashable_count=$(git rev-list --count $fork_point_commit..$current_commit)

    ## Exit, if passed squash_count_opt is `0` or not a `number`!
    if [[ $squash_count_opt != "" && ( ! $squash_count_opt =~ ^[0-9]+$ || $squash_count_opt == 0 )]]; then
        echo "Invalid Squash Count $squash_count_opt! " && return 1
    elif [[ $squash_count_opt == ""  ]]; then
      squash_count_opt=$squashable_count
    fi

    ## Exit, if found `squashable_count` turns about to be `0` !
    if [[ $squashable_count == "0" ]]; then
        echo "Nothing to Squash! " && return 1
    fi

    ## Squash Count Passed cannot be more than Squashable Count found!
    if [[ $squashable_count < $squash_count_opts ]]; then
        echo "Cannot Squash more than $squashable_count! " && return 1
    fi

    # Squash!: Get Commit Message and Description.
    # ----------------

    ## Get Commit Message, (Default: title from latest commit)
    if [[ $commit_msg_opt != "" ]]; then
      local commit_message=$commit_msg_opt
    else
      local commit_message=$(git log --format="%s" -n1)
    fi

    ## Get Full Commit Description, (Default: raw body from last n commit)
    if [[ $add_full_desc_opt == true ]]; then
      if [[ $commit_desc_opt != "" ]]; then
        commit_desc_opt="$(echo $commit_desc_opt) $(git log --format='%B' -n$squash_count_opt)"
      else
        commit_desc_opt="$(git log --format='%B' -n$squash_count_opt)"
      fi
    fi

    ## create commit_desc_if_there if commit_desc_opt is populated
    local commit_desc_if_there=""
    if [[ $commit_desc_opt != "" ]]; then
      commit_desc_if_there=$(echo "-m '$commit_desc_opt'")
    fi

    # Squash!: Reset Commits Softly before commiting back.
    # ----------------

    ## Normally Squashing is done using rebase,
    ## but I could not automate its interactive shell.
    git reset --soft HEAD~$squash_count_opt

    # Squash!: Commit to complete squashing!
    # ----------------

    ## Use Auto Commit Command if There, Else use Default `git commit`
    if [[ $commit_msg_opt == "" && $(command -v gac) ]]; then
        gac $commit_desc_if_there
    else
        git commit -m "$commit_message" $commit_desc_if_there
    fi
}

Git Auto Commit (gac):

gac() {
    ## The Idea is to create a commit message from branch name
    ## For Example:
    ##    if branch name is `feature/jira-123-this-is-issue-desc`
    ##    then commit would be `[Enhancement JIRA-123] This Is Issue Desc`

    # Exit, if there is nothing to commit!
    if [[ $(git diff --staged) == "" ]]; then
        echo "Nothing to Commit! " && return 1
    fi


    # Fetch Details
    # ----------------

    ## `feature/jira-123-this-is-issue-desc`, all in lower case
    local current_branch=$(git rev-parse --abbrev-ref HEAD | tr '[:upper:]' '[:lower:]')

    ## `feature`
    local issue_type=$(echo $current_branch | cut -d '/' -f 1)

    ## `jira-123`
    local issue_no=$(echo $current_branch | cut -d '/' -f 2- | cut -d '-' -f -2)

    ## `this-is-issue-desc`
    local issue_desc=$(echo $current_branch | cut -d '/' -f 2- | cut -d '-' -f 3- )


    # Format Details
    # ----------------

    ## We will use this map to get issue_type out of branch name
    declare -A branch_map; branch_map["feature"]="Enhancement";
    branch_map["bugfix"]="Patch"; branch_map["version"]="Upgrade";

    ## `feature` -> `Enhancement`; `random` -> `Random`
    issue_type=${branch_map[$issue_type]-${issue_type^}}

    ## `jira-123` -> `JIRA-123`
    issue_no=$(echo $issue_no | tr '[:lower:]' '[:upper:]')

    ## `this-is-issue-desc` -> `This Is Issue Desc`
    issue_desc=$(echo $issue_desc | sed 's/-/ /g' | awk '{for (i=1; i<=NF; i++) $i=toupper(substr($i,1,1)) tolower(substr($i,2))}1')

    ## `[Enhancement JIRA-123] This Is Issue Desc`
    local commit_msg="[$issue_type $issue_no] $issue_desc"

    # Commit!
    # ----------------

    ## Along with this message, I have added $@, So that all the
    ## flags and arguments of `git commit` can be passed in this command.
    git commit -m "$commit_msg" $@
}

Git Fetch Rebase (gfrb):

gfrb() {
    ## If $1 is not passed, then it will fetch the default branch
    local base_branch=${1:-$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')}
    git fetch origin "$base_branch":"$base_branch"

    ## Rebase requires stashing, but any file that has both
    ## staged and unstaged changes will lose all its
    ## unstaged changes! So uncomment at your own risk.

    # git stash --all

    git rebase "$base_branch"

    # git stash pop
}

Git Upstream Push (gup):

gup() {
    ## Although `--force` is frequently used in this workflow.
    ## It still feels destructive to add here.
    ## Instead I have added $@, So that all the `git push` 
    ## flags and arguments can be passed in this command.
    local current_branch=$(git rev-parse --abbrev-ref HEAD)
    git push --set-upstream origin "$current_branch" $@
}

Update your ~/.[ba|z]shrc with these productive commands and save those few minutes. Happy Commiting!

You also might like these:

• Check out my gist (alias.sh) for a big list of aliases for git, python, Django, and docker.

• Made a meme into reality - New Bash Alias: Git Out

• And Finally, a fun video - Bash Script: Enjoy the Little Things!

PS: Feel free to share your productivity Hack!

To create an iterable blockchain, which could work with an extendable transaction class. Here the link GitHub repo!

Blockchain in Brief:

• Blockchain is fundamentally a ledger maintaining records of transaction, This ledger is publicly distributed.

• Blockchain is a sort of linked-list of Blocks, A Block is a data-structure, that contains a set of transactions.

• Whenever a transaction happens, transferring party adds a reward for the "Miner".

• A "Miner" picks the set of transactions to be added in block till block-weight-limit (max allowed size of the block) is reached, then "Miner" does some heavy computation as proof of work and then sends the mined block in the world to add in each individual ledger.

• These Transactions need not be monetary but could be anything that you want to make immutable.

Scope of this Project:

• Will not be doing any server-side operations.

• Will create a data-structure complete with custom error and iterators.

• Miners reward will be sent out by the admin.

• No block-weight-limit.

• Our Own Custom Proof of Work.

• Extendable/Inheritable Transaction Class

Plan of Attack:

• We are going to use RSA for our encryption needs.

• Extendable base_transaction class.

• Create block class with Transaction and HashFunction templates.

• Create a blockchain class with the same templates and custom iterators to make it iterable.

Setup

Lets Setup the extra files!

RSA: Library will be used for signing and verification of transactions.

Create a includes folder and add files from Github

not_implemented_exception: The exception that is thrown when a requested method or operation is not implemented.

class not_implemented_exception : public logic_error
{
public:
    not_implemented_exception(
        string function = __builtin_FUNCTION()
    ) : logic_error("`" + function + "` not implemented!"){};
};

base_transaction<EncryptionAlgo>

Here are the required things:

• Parametric Constructor with from_addr, to_addr, transfer_amount

• Hash Generator function (generate_hash_input)

• Override string Operator (for string type casting)

• Override << Operator (for cout)

• Override < Operator (for comparison)

• Function to get balance based on address (get_balance(addr))

• Function to sign transaction (sign_transaction(key_pair))

• Function to validate transaction (is_transaction_valid(verifying_func))

Every Function logic will be same, which is to throw not_implemented_exception, for example:

operator string() const {throw not_implemented_exception();}

custom_transaction : public base_transaction<EncryptionAlgo>

Private Members:

• from_address (Yours public_key)

• to_address (Others public_key)

• transfer_amount

• timestamp

• signature (Initially 0, will be updated in sign_transaction)

Public Members:

• Parametric Constructor with from_addr, to_addr, transfer_amount

custom_transaction(from_adrr, to_addr, amount){ from_address = from_addr; to_address = to_addr; transfer_amount = amount; timestamp = chrono::steady_clock::now(); signature = 0; }

- Hash Generator function (`generate_hash_input`)

> ```python
# Concatenation of all stringified private variables (except Signature)
# to_string(...) in C++
return (str(from_addr) + str(to_addr) + str(amount) + str(timestamp))

• Override string Operator (for string typecasting)

operator string() const { string from_address_str = "\nfrom_address: " + to_string(from_address); string to_address_str = "\nto_address: " + to_string(to_address); string transfer_amount_str = "\ntransfer_amount: " + to_string(transfer_amount); string signature_str = "\nsignature: " + to_string(signature); return from_address_str + to_address_str + transfer_amount_str + signature_str; }

- Override `<<` Operator (for `cout`)

> ```C++
friend ostream &operator<<(ostream &out, custom_transaction const &temp)
{
  // Using above string operator
  return out << string(temp);
}

• Override < Operator (for comparison)

bool operator<(const custom_transaction &other) const { return generate_hash_input() < other.generate_hash_input(); }

- Function to get balance based on the address (`get_balance(addr)`)

> ```C++
float get_balance(addr) const
{
  if (addr == to_address)
    return transfer_amount;
  if (addr == from_address)
    return -transfer_amount;
  return 0;
}

• Function to sign transaction (sign_transaction(key_pair))

Here are some Pointers regarding signing

• A Transaction is signed by the party making transaction therefore our from_address should match public_key in key_pair. Let us create an Error Regarding that:

class public_key_mismatch : public invalid_argument { public: public_key_mismatch( string addr, std::string pk) : invalid_argument("from_addr: '" + addr + "' do not match public_key: '" + pk + "'"){}; };

> - A Transaction is can be signed once, Let us create a Exception Regarding that:
> ```C++
class resign_transaction_exception : public logic_error
{
public:
    resign_transaction_exception(string transaction) : logic_error("Resigning Transaction!" + transaction){};
};

• Signing of Transaction refers Signing the stringified Transaction class i.e. output of generate_hash_input()

template bool sign_transaction(EncryptionAlgo key_pair) { if (from_address != key_pair.get_public_key()) throw public_key_mismatch(to_string(from_address), to_string(key_pair.get_public_key())); if (signature != 0) // already signed throw resign_transaction_exception(*this); signature = key_pair.sign(generate_hash_input()); return true; }

- Function to validate transaction (`is_transaction_valid(verifying_func)`)

> ```C++
bool is_transaction_valid(bool (*verfication_function)(string, size_t, address)) const
{
  // reward, since reward is given by admin, there is no key pair
  if (from_address == 0)
    return true;
  return verfication_function(generate_hash_input(), signature, from_address);
}

block <Transaction, HashFunctionClass>

NOTES:

• A block typically contains the following:

• ID

• Previous Hash

• timestamp

• nonce ("number used once") a 32-bit, data computed in proof-of-work

• A set of Transactions (Merkel Tree)

• Hash (stringification of all of the above)

• hash_function is an instance of template class used for all hashing related needs (std::hash used in main.cpp)

• Proof of Work:

• Calculating Hash in such a way that it becomes computationally intensive. A way to make it happen is:

Here nonce is found via brute force

until HASH_PATTERNis matched.

while(1): hash_input = str(...) + str(nonce) if re.match(hash_function(hash_input), HASH_PATTERN): return nonce nonce += 1

 - In **BitCoin**:
  - hash_function: `sha256`
  - HASH_PATTERN: Starting with `n` zeros, higher the `n`, harder to compute.

 - In `namespace::ra` :
  - hash_function: Template (`std::hash<string>` for reference)
  - HASH_PATTERN: hash length must be `15/n`, lesser the n, harder to compute.





#### `block_chain <Transaction, HashFunctionClass>`

Well as the name states it is a chain of blocks, So Naturally, It will contain the same Template Arguments as `Block`

Private Members:
- `list<BlockType> chain` (A list of blocks)
- `list<Trasaction> pending_transaction` (Temperaroy Buffer before mining (_create a block and adding it to list_))
- `difficulty` (to be passed in `block` class)
- `minning_reward` (If exists, will add a new transaction from admin before mining block)
- `verfication_function` (to verify block or transaction itself)

Public Members:
- Iterator Class (To make iteration easy)

> - Private:
>  - `std::_List_iterator<block_type>` block_ptr, 
> - Public:
>  - Override `==`, `!=`, `++`, `&++`, `--`, `&--`, for example:

>>> ```C++
iterator operator--(int)
{
    iterator _temp = *this;
    m_block_ptr--;
    return _temp;
}

• Override the following to work with iterator class

const iterator begin() { return chain.begin(); } const iterator end() { return chain.end(); } block_type &back() { return chain.back(); } block_type &front() { return chain.front(); } int size() { return chain.size(); }

- `block_chain(diffuculty, verfication_function, minning_reward)` Constructor:
 - Update all the private variable by this constructor
 - Add A Genesis Block to chain! 


- get_balance(): 
 - `float balance = 0`
 - Iterator over the `block_chai`n from `begin()` to `end()` using iterator class and add it to `balance`
 -  return `balance`


- `add_transaction(temp)`
 - check `temp` using `is_transaction_valid` by passing in `verfication_function`
 - add to `pending_transaction` else Throw Error


- `mine_pending_transactions(minning_reward_address)`
 - if `minning_reward` exsits, add a reward `transaction` to `minning_reward_address`, else continue
 - create a block with `pending_transaction`, and push it to chain.
 - clear `pending_transaction`.

- `is_chain_valid()`
 - Iterator over the `chain`, check the validity of current block using `is_block_valid` by passing in `verfication_function`
 - check if `previous_hash` of current block matches `hash` of the previous block

All the code can be found at the below link:
https://github.com/ra101/Generic-BlockChain-container-cpp

To create a working RSA code, Using namespace ra::random_prime_engine, Here the link GitHub repo!

What is RSA?

The Rivest-Shamir-Adleman (RSA) is an asymmetric encryption algorithm. Asymmetric Encryption is when a box(data) can be locked by one key and unlocked by other. locking key cannot unlock the box and vice-versa. The locking key is the public key and the unlocking key is the private key, Public key is called so because we publicly distribute it, so anyone/everyone would send the user an encrypted msg, and the user can unlock it in private with the private key. By keeping private to the user-self, no hacker can get a method of unlocking it.

How RSA Works?

https://ra101.hashnode.dev/rsa-encryption-algorithm

Code:

• Private Members:
  • private_key
  • public_key
  • create_key(long seed)

• Public Members:
  • Constructor & Constructor(seed)
  • std::size_t decrypt(std::size_t);
  • std::size_t decrypt_with_padding(std::string);
  • Key Getters
  • std::size_t sign(Message message)

• Other Function within namespace but Outside class (All the functions utilizing public key):
  • std::size_t encrypt(std::size_t digest, public_key);
  • std::string encrypt_with_padding(std::size_t digest, public_key);
  • bool verify(Message message, size_t digest, public_key)
  • string padding(string)

Constructors:

The seed in the constructor is used in random prime engine and the logic of the seed argument is as follow,

# pseudo code implemented in python
def constructor(seed=None):
    if not seed:
        seed = timestamp()
    else:
        seed = hash(seed)
   return create_key(seed)

// Usage

ra::rsa_key_pair k1, k2("127.0.0.1");

create_key(seed) function,

I will not get into the mathematics of it all, but in the end, using 2 primary numbers we get

• public key: (n, e)
• private key: (n, d)

(n, e, d) all are integers.

To concatenate these two numbers (n, e/d) let us define a big number BIG_NO, such that

• n = key / BIG_NO
• e = public_key % BIG_NO
• d = private_key % BIG_NO

#define BIG_NO 100000000000

public_key = n * BIG_NO + e;
private_key = n * BIG_NO + d;

encrypt(digest, key) function,

return (digest ** e) % n

decrypt(encrypted_data) function,

return (encrypted_data ** d) % n

padding(string str) function,

#define PAD_SIZE 10

// 12345 -> 0000012345
while (str.length() < PAD_SIZE)
{
    str = '0' + str; // add 0 in front of no.
}
return str;

encrypt_with_padding(digest, key) function,

# encrypt each digit
for each_digit in digest:
    output = padding(encrypt(each_digit)) + output
return output

decrypt_with_padding(encrypted_data) function,

# cut the input string in chunks of length PAD_SIZE
# decrypt each chunk to digit and then form a output
for i_chunk in len(encrypted_data)/PAD_SIZE:
    i = i_chunk * PAD_SIZE
    digit = decrypt(int(encrypted_data[i: i + PAD_SIZE]))
    output = digit + output * 10
return output

sign(Message message) function,

return decrypt(hash(message))

verify(Message message, digest, others_public_key) function,

return ( hash(message) == encrypt(digest, others_public_key) )

All the code can be found at the below link: https://github.com/ra101/RSA-cpp

The Rivest-Shamir-Adleman (RSA) is an asymmetric encryption algorithm. Asymmetric Encryption is when a box(data) can be locked by one key and unlocked by other. locking key cannot unlock the box and vice-versa. The locking key is the public key and the unlocking key is the private key, Public key is called so, because it is publicly distributed, so anyone/everyone would send the user an encrypted msg, and the user can unlock it in private with the private key. By keeping private to the user-self, no hacker can get a method of unlocking it.

How Asymmetric Encryption is achieved?

We need a mathematical function such that

f: public key function , g: private key function
f-1(f(msg)) != msg
g(g-1(msg)) != msg
g(f(msg)) == msg

Signing Document via Asymmetric Encryption:

Digital Signature is the by-product of Asymmetric Encryption, In most asymmetric encryption algorithms (including RSA), public and private are just names, one can simply interchange them for locking and unlocking. Here is how to sign a document:

How to sign:

• Step 1: Calculate hash of the document using an unbreakable and popular hashing algorithm (for eg. SHA-256)
• Step 2: Make digest by performing the decryption function with the private key on that hash.
• Step 3: Send the document, digest, and hashing algorithm to the world.

How to Verify:

• Step 1: Calculate the hash of the document using the provided hashing algorithm, let's call it the "calculated hash".
• Step 2: Get the hash by performing the encryption function with the user's public key on that digest, let's call it the "given hash".
• Step 3: If "calculated hash" matches with the "given hash" then the document is authentic else not.

Mathematics of RSA:

for g and f should be such that g must relatively harder to perform so that it could not be cracked by brute force.

First, let's get this straight. Every string data can be represented as numbers or chunks of numbers, which can happen via ASCII or change it to binary then to decimal. So mathematical operation can be used on any and every data.

Consider m as the message. say m is 10, now we have to find 2 functions, one that will change it some else and the other that can change back!

Multiplication/Division:

let f(key, m) = key * m so now we have to distribute f and key but same key can be used to change it back!

Addition/Subtraction:

let f(key, m) = key + m so now we have to distribute f and key but same key can be used to change it back!

Trigonometry:

let f(..., m) = sin(... m) Here the problem is the decimal nature of output, can have different result at different machines!

Modulus: For those who are new to modulus function, it is the reminder of integer division.

x mod y => ky - x where ky > x for example: 7/5 = 1 and 2 = 7 mod 5

Here is the catch, for

2 = m mod 5 m can be 2, 7, 12... 5*(x) + 2 So a hacker with 2 (encrypted msg) and 5 cannot decode the m, but so can't we.

Let us try one more trick

3mmod 5 = x
for if m is 0, 1, 2, 3, 4 ... x is 1, 3, 4, 2, 1 ... respectively, m is uniformly distributed in 1 to 4. So a hacker with x (encrypted msg), 5 and 3 cannot decode the m, but still so can't we. Another major point to be noted is, if 3 < 5 exists, then x == 3 for some m and x < 5 exists always.

Now Let us merge both tricks.

memod n = x, m < n --> eq 1
m: message, e, n: some constants, x: encrypted message Let there be another equation

xdmod n = m --> eq 2
x: encrypted message, d, n: some constants, m: message
Let us substitute x in eq 2 with eq 1

(mdmod n)emod n = m
me * dmod n = m
m: message, e, d, n: some constants, x: encrypted message in other words: e -> public_key and d -> private_key All we need is do is define those constants and we are good to go!

Now Lets take a dive into history,

Introducing the Totient function aka Euler's phi function

phi(n) = m, m is the count of integers b/w [1, n], which are coprime(relatively prime) to n
for example, phi(8) = 2 as, gcd(6, n) == 1 holds true only for 1 and 5.

• Interestingly enough, phi(prime) is always prime - 1, as all the numbers before prime gave their gcd as 1, given the definition of prime is exactly that.
• Another Observation is phi(p1 * p2) = phi(p1) * phi(p2)

Let's cook with the ingredients we have.

• phi(n) = Set of all the co-primes
• 3emod 5 = x,
  for if e is 0, 1, 2, 3, 4 ... x is 1, 3, 4, 2, 1 ... respectively, e is uniformly distributed in 1 to 4.
• Let there be ak, such that ak= 1 mod n
• Since, is k one of the uniformly distributed power, it must be within phi(n), therefore phi(n) = kc, there c is some constant.
• Now if raise both side with power for c
• It becomes: akc= aphi(n)= 1 mod n This is Fermat–Euler Theorem

Merge both the discoveries:

a * aphi(n)mod n = aedmod n
a * aphi(n) * c= aedmod n
(phi(n) * c) + 1 = e * d
if n is product of big prime number then phi(n) easy to calculate and n itself hard to find (prime factorization would take a lot of time) d = (c * phi(n) + 1) / e
where c is calculated such that d becomes an integer (n, e) : public key, (n, d): private key

Bibliography / Resources:

RSA Brief: https://www.youtube.com/watch?v=wXB-V_Keiu8

Khan Academy: https://www.khanacademy.org/computing/computer-science/cryptography/modern-crypt/v/intro-to-rsa-encryption

Proof of Fermat–Euler Theorem: https://www.youtube.com/watch?v=5pswKNgVZSg

RSA SIgning: https://www.cs.cornell.edu/courses/cs5430/2015sp/notes/rsa_sign_vs_dec.php

To create a random number engine that generates prime number on the go! Here the link GitHub repo

Plan of Attack:

• Since finding prime number in constant time is impossible by the math at the moment, So We are going to use a database-based approach. Lets store all the prime number in primeDB file
• Since C++ already have random engines, Let us create a wrapper around that using templates

Objective:

• Container that takes in engine class and override all the engine functions, also takes in filepath for database
• Functions to override
  • () -> returns random prime number
  • min() -> returns min prime number
  • max() -> returns max prime number
  • << -> save the state to std::stringstream
  • >> -> restores the state from std::stringstream

Code:

• Private Members:
  • template <typename Engine> Engine eng;
  • int min_prime;
  • int max_prime;
  • char const *db_filepath;

• Public Members:
  • Constructor
  • int operator()();
  • friend stringstream &operator<<
  • friend stringstream &operator>>

Constructor: takes in seed and filepath

#define DB_FILEPATH "primeDB"

template <typename Engine>
random_prime_engine<Engine>::random_prime_engine(unsigned long rand_seed, char const *db_filepath=DB_FILEPATH)
{
    // Get DB path
    this->db_filepath = db_filepath;
    eng.seed(rand_seed);
}

// Usage

ra::random_prime_engine<std::default_random_engine> rpe_2(rand_seed);

() operator,

#define DB_SIZE 10000

template <typename Engine>
int random_prime_engine<Engine>::operator()()
{
    int idx = eng() % DB_SIZE; // to get a index within file
    int rand_prime;

    // Open the file
    std::ifstream file;
    file.open(db_filepath);

    // update rand_prime till it gets the value at index
    for (int i = 0; i <= idx; i++)
        file >> rand_prime;

    file.close();
    return (rand_prime);
}

// Usage

std::cout << rpe()

min and max

# pseudo code
# initialize min/max with 0, for lazy initialization

{
    # return min or max if once found
    if bool(min/max):
        return min/max

    min = file.first_line
    max = file.last_line

    return min/max
}

>> and <<

// Friend Functions
#define stringstream SS
function SS &operator<>(SS&in/out, rpe){
    in/out >> rpe.eng;
    return in/out
}

// Usage

std::stringstream state;
state << rpe; //save current state
state >> rpe; //restore old state

All the code can be found at the below link: https://github.com/ra101/Random-Prime-Number-Generator-Engine-cpp

Well, I knew what my task of day is going to be. Below is the report of my 3 hour investigation into Emoji Domains.

How are they possible?

To create standardization in Internet hostnames every domain name is encoded into punycode, a LDH (letters, digits, and hyphens) subset of ASCII, by browsers before URL encoding it. pseudo code for the flow can written as:

final_url = url.encode(
    punycode.encode(domain.name) + '/rest of the path'
)

Now, by only using LDH, other ASCII char are converted into xn-- form, some examples are:

• ü -> xn--tda
• 人 -> xn--gmq
• 😀 -> xn--e28h

links: punycoder.com | urlenc.com

Why are they so rare?

With the restriction of LDH many hosting services also add the rule that - must be surrounded by characters to decrease changes of scamming or exploits therefore making -- illegal.

Click Here to know more.

Loop-Hole: According to wikipedia, As of April 2021, there are eleven top-level domains for which registration is possible: .uz, .cf, .ga, .gq, .ml, .tk, .st, .fm, .to, .kz and .ws

Lets get one!

I noticed .tk, and I remembered long ago they were giving redirector domain names for free that too without signup. I checked back, sadly that was not the case anymore, Although the fees was not that much, But I am not willing to pay for a detour in my evening.

Okay if we can't have domain name, lets get a subdomain, I already have a InfinityFree account, So lets try there, but it looked at -- and said no latin letters, So, I looked around and found some websites but I had to input my card info, so i backed out.

Finally, ProFreeHost was my saviour, I quickly setup an account, found how to redirect the url, only thing left was to think of a domain name, After ton of soul searching, there it was on my youtube feed, Lightyear | Teaser Trailer. So I went to infinity and beyond and created my website: 2️⃣♾️➕🚀.unaux.com

If you make/made your own Emoji Website, comment below and share with us as well.

I couldn't find a good implementation of constants, so created my own! Let's get started!

Do checkout the complete code at https://gist.github.com/ra101/aa27ff6e437f74ca56027a8c6b166882

How it Should work

    class Links(ConstantClass):
        GITHUB = "https://github.com/ra101"
        WEB = "https://ra101.github.io/"
        LINKS = "dev.ra.101@protonmail.com"

    class Author(ConstantClass):
        NAME = "〈 RA 〉"
        WEB = Links.WEB
        LINKS = Links

Now Links.GITHUB should return https://github.com/ra101 and Link.GITHUB = 'new_value' or Links.NEW_CONTANTS = NEW_VALUE both should return None, without assigning or creating new field

Here is How I made it!

1. We need to mock all setter in a meta class, which will be used by main class.

class ConstantMeta(type):
    """
    Meta Class for Constant, How Constant class would behave
    """

    def __setattribute__(self, *args, **kwargs):
        # Override set method to make it immutable
        pass

    def __setattr__(self, *args, **kwargs):
        # Override set method to make it immutable
        pass

    def __setitem__(self, *args, **kwargs):
        # Override set method to make it immutable
        pass

    def __set__(self, *args, **kwargs):
        # Override set method to make it immutable
        pass

1.5) Lets add a external setter

    def __force_set__(self, name, value):
        # A external set method to make sure we can update value in __new__
        return super().__setattr__(name, value)

1. Override __new__ to make the actual class

    def __new__(cls, clsname, bases, clsdict):
        """
        adding __keys__, __values__ fields
        and keys(), values() methods
        """
        obj = super().__new__(cls, clsname, bases, clsdict)
        obj.__force_set__("__values__", [])
        obj.__force_set__("__keys__", [])
        for key, val in vars(obj).items():
            if not key.startswith("__"):
                obj.__values__.append(val)
                obj.__keys__.append(key)
        obj.__force_set__("keys", lambda: obj.__keys__)
        obj.__force_set__("values", lambda: obj.__values__)
        return obj

2.5) Add below methods for polishing the class

    def __getitem__(cls, key):
        # adding __getitem__ to make objects "subscriptable"
        return getattr(cls, key)

    def __iter__(cls):
        # In case of for loops
        return zip(cls.__keys__, cls.__values__)

1. Finally Lets create the class!

class ConstantClass(metaclass=ConstantMeta):
    """
    Now this class can be inherited whenever required to make constants
    """

    pass

Finally! We are Done! We Created a almost immutable class that could be used as constants

Examples

Input:

    class Links(ConstantClass):
        GITHUB = "https://github.com/ra101"
        WEB = "https://ra101.github.io/"
        LINKS = "dev.ra.101@protonmail.com"

    class Author(ConstantClass):
        NAME = "〈 RA 〉"
        WEB = Links.WEB
        LINKS = Links

    Links.WEB = 'any_new_value'

    print(f"\nLinks.WEB: {Links.WEB}")
    print(f"\nAuthor.values(): {Author.values()}")
    print(f"\ndict(Author): {dict(Author)}")
    print("\nfor key in Author.LINKS.keys()")
    for key in Author.LINKS.keys():
        print(f'getattr(Author.LINKS, "{key}"): {getattr(Author.LINKS, key)}')

Author.values(): ['〈 RA 〉', 'https://ra101.github.io/', <main.ConstantClass object at 0x00000293A94768E0>]

dict(Author): {'NAME': '〈 RA 〉', 'WEB': 'https://ra101.github.io/', 'LINKS': <main.ConstantClass object at 0x00000293A94768E0>}

for key in Author.LINKS.keys() getattr(Author.LINKS, "GITHUB"): https://github.com/ra101 getattr(Author.LINKS, "WEB"): https://ra101.github.io/ getattr(Author.LINKS, "EMAIL"): dev.ra.101@protonmail.com

Do checkout the complete code at https://gist.github.com/ra101/aa27ff6e437f74ca56027a8c6b166882

https://t.me/MasquerBot

I watched Snowden in 2016. It was the year, I became paranoid. 👻

Introducing 𝗠𝗮𝘀𝗾𝘂𝗲𝗿𝗕𝗼𝘁! It is a telegram_bot that can hide any given text message inside any given image, by manipulating the very pixels of that image (steganography)

• URL changes every 6 hrs, with 130 char long, therefore making it impossible to trace by anyone other than Telegram.

𝘍𝘢𝘳 𝘣𝘦𝘵𝘵𝘦𝘳 𝘥𝘰𝘤𝘶𝘮𝘦𝘯𝘵𝘢𝘵𝘪𝘰𝘯 𝘪𝘴 𝘰𝘯 𝘨𝘪𝘵𝘩𝘶𝘣, 𝘭𝘪𝘯𝘬𝘴 𝘢𝘵 𝘵𝘩𝘦 𝘦𝘯𝘥.

📈 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄:

• It works by creating an ECDSA encryption 🔑🗝key pair, returns you the 🔑public key, to distribute.

• To encrypt, one will have to send your 🔑key along with ✉text and 🖼image.

• The bot will encrypt the text and hide it then it will return the 🖼 encode-image.

• You as a recipient will send the encoded-image to the bot. and it will take your 🗝private key from the 📒database and will send you the hidden ✉text.

PS: Icon is not just eye-candy for otakus. try "/icon" command, within the bot. I bet you will love it. 😉

⚡𝗟𝗶𝗻𝗸𝘀: Github: https://github.com/ra101/MasquerBot LBRY: https://lbry.tv/@ra101/MasquerBot

Much to my suprise, I was not able to control brightness with this new keyboard.

• No function keys were mapped to brightness settings
• There was no specific keys for that
• Even G Hub software had no System Action for brightness

So, the dev inside me said, lets tackle it with software!
By the help of stack-overflow and powershell docs, I wrote a simple powershell script, to adjust my brightness... {% gist https://gist.github.com/ra101/c2060ade52280b4fcbe3291331caf1e0 %}

.\brightness.ps1 <# No agrs will increase brightness (+10) #>

.\brightness.ps1 desc <# desc as arg will decrease brightness (-10) #>

Now I compiled this file to .exe, to replicate that,

• First Install ps2exe module in powershell (as admin)

  Install-Module ps2exe
  

• Simply use this module to convert ps1 to exe

  Invoke-ps2exe .\brightness.ps1 .\brightness.exe -noConsole
  

First I thought of using AutoHotKey, but i couldn't utilise any function key there. So, settled with G-Hub instead

Now, head over to G-Hub add this file as application, twice , one for +10 and other for -10, remember to add desc there and then change whatever Function keys you want map to brightness.

FYI: I used F6 key to change to G-shift mode. and F7 to increase brightness and F8 to decrease brightness in G-shift mode. No updation made in default mode.

Please comment, for any suggestion regarding this keyboard, or any wonderful hack you have in mind.

But not today, Not anymore! Let's right the wrongs of this society! So, if you are with me!

Open Your .bashrc File!

nano ~/.bashrc

Add This Line! & Save it! (ctrl+x, y, return)

git() { if [[ $@ == "out" ]]; then command "exit"; else command git "$@"; fi; }

And Finally! Source it!

source ~/.bashrc

Good job! Be Proud! Because of you, there is one less lonely command!

PS: Feel free to share any meme command out there.

I coded my first C++ libraries 5 years back, I had just started college, and wanted to do something solid!, One fine evening, I was looking back at that code, It was so, poorly written, So I started fixing it. I googled C++ Convention, After many search results, I found out there are no good resources out there. So I took upon myself, To Write One!

These are coding practices one may follow to write readable good code.

File Types:

Any programing file, in the end, is nothing but a text file with a fancy extension. In the Book of Genesis, the mentioned naming style is:

• .c for C
• .cpp for C++
• .h for headers (independent of C or C++)

But due to the opensource nature of GNU, A bunch of different assembler and compilers were made which came with their own extensions variations, such as, .cc, .C, .cxx, .c++ and .hh, .H, .hxx, .hpp, .h++.

TBH, Just chose one set of extensions, after all, even .txt can be compiled.

I use, (Since Most IDE recognize them):

• .c for C
• .cpp for C++
• .h for C headers
• .hpp for C++ headers

makefile:

A makefile is a special file, containing shell commands, that you create and name makefile (no extensions)

It is executed using the make command. My Typical makefile looks like this:

# Variables
CXX=g++
CXXFLAGS=-std=c++11 -w

# <command> : <dependencies>

# would have worked with main.cpp as well, added rest of
# dependencies to add a check before compiler returns an error.
build: main.cpp local_header.hpp includes/external_lib.hpp 
    @echo "\n\nmain.cpp: Building..."
    $(CXX) $(CXXFLAGS) -o main.out main.cpp

run: main.out
    @echo "\n\nmain.cpp: Executing..."
    ./main.out

clean: main.out
    @echo "\n\nmain.cpp: Cleaning..."
    rm main.out

# test command is for show, I have probably never used it 😅😂 
test: test.cpp
    @echo "\n\ntest.cpp: Building..."
    $(CXX) $(CXXFLAGS) -o test.out test.cpp
    @echo "\n\ntest.cpp: Executing..."
    ./test.out
    @echo "\n\ntest.cpp: Cleaning..."
    rm ./test.out

all: build run clean

$ # To build, run and clean the main.cpp
$ make all

One can use something like GNU Automake or CMake instead of hand-written makefiles. These tools may add the overhead of other files, but these files are informative files. Use these tools, if they benefit your project.

NOTE: use -MMD flag to get a .d file, containing all dependencies.

PreProcessors:

The preprocessors are the directives, which instruct the compiler to preprocess the information before starting compilation. All preprocessors start with #, For example: #include<iosteam>

These are the coding practices, I use:

• Double Quotes ("...") for including local headers, This rule increases readability of Code

• 3 Levels of includes (I picked this habit while working in python) with linespace between them.

  • First, for core g++ system files.
  • Second, for externally added libraries.
  • Third, for locally created files.

As mentioned here one should include local headers first — then system headers. The reason is to guarantee that all local headers are self-sufficient

"self-sufficient" means, local headers are not depending on System or External libraries. This although is a good way of checking, I believe this "check" is not something headers/compilers should do, well at least not at the file level. In an ideal world, Each header would have its own test files to resolve this, until then, going against the natural order might not be that bad.

• #pragma one for header files

  • What #include does is that it adds the mentioned file at the top of the code (you can check it by using --save-temp flag during compiling) So, If a header file is called again somewhere else, The Whole Code will be compiled again. Since Header files don't typically initiate a variable. It is Advised to compile it once for performance enhancement.
  • One can use #indef ... #include ... #endif, but it is tedious, so#pragma once reduces possibilities for bugs due to manual mishandling.

• DO NOT USE using namespace ... in header file

  • It may lead to a re-declaration error.
  • It may populate the header file with its function

SO, According to the above rules, A good header would be.

#pragma once // 2 line-space afterwards


#include<system_file_1>
#include<system_file_2> // 1 line-space afterwards

#include<external_lib1_1> // 1 line-space afterwards
#include<external_lib2_2> // club external libs together
#include<external_lib2_3> // 1 line-space afterwards

#include "local_file" // 2 line-space afterwards


// using namespace ... DO NOT USE IN HEADERS

namespace ra {
...
}

Nomenclature:

File | namespace | Class | function:

• Nothing is fixed, one may use camelCase, PascalCase or snake_case.
• I personally find snake_case to be more readable.

Template Parameter:

• same as above, no rules.
• I prefer PascalCase here.

Constants | Macros:

• UPPER_SNAKE_CASE is preferred everywhere.

Variables:

• Before IDE(s) were a thing, People just couldn't hover over variables to get info. So some old libraries use the following conventions:
  • m_<any case> for private members
  • t_<any case> for function parameters
• I personally, discard this rule.

Taboo of Naming:

Check this link

Comments:

C++ allows for 2 types of comments:

// This is single line Comment

/*
...
This is Multi-Line Comment
...
*/

Generally speaking, single-line comments provide more control over the appearance and are considered better.

As a python developer, I wholeheartedly disagree, This is how I prefer my code!

class custom_class {
    /*
        A definition of what does this class represent
        - Preferred Usage:
            ...
    */
    private:
        // How this variable affects / Where this may be used
        float variable {3.14};

        // What does this function do
        void function();
}

void custom_class::function(){
    /*
        A definition of what does this function do
        - Input: ...
        - Output: ...
    */
}

Custom Exceptions:

Custom exceptions provide you the flexibility to add attributes and methods that are not part of a standard programming language. These are most helpful in Debugging when code is unable to compile.

Below is My Favorite Exception:

// Code

namespace ra
{
    class external_exception : public std::logic_error
    {
    public:
        external_exception(
            std::string function = __builtin_FUNCTION()
        ) : std::logic_error("`" + function + "` called for external exception!"){};
    };
}

// Usage

void main (){ throw ra::external_exception(); }

# Output

terminate called after throwing an instance of 'ra::external_exception'
  what():  `main` called for external exception!

Let me explain, In argument of constructor of exception it says:

std::string function = __builtin_FUNCTION()

__builtin_FUNCTION() return the source location, when called.

Since called in Argument, whenever it is initiated that is the source location, Essentially Making it a traceable Exception

Here We have inherited from logic_error, but other exceptions/errors could be found here

NOTE: In C++ Exceptions and Errors are the same, but in theory, Exceptions are something that could be handled, whereas errors should not be as they break the system.

Modularity

A Modular design is shown to improve the design process by allowing better re-usability, relatively low maintenance, workload handling, and easier debugging processes. Modularity in C++ can be achieved by the following

Template

As defined (here)[https://www.javatpoint.com/cpp-templates]: A C++ template is a powerful feature added to C++. It allows you to define the generic classes and generic functions and thus provides support for generic programming. Generic programming is a technique where generic types are used as parameters in algorithms so that they can work for a variety of data types

Templates can be represented in two ways:

• Function templates

template <typename TemplateKlass>
TemplateKlass get_maximum(TemplateKlass x, TemplateKlass y){
   return (x > y)? x: y;
}

• Class templates

  template <typename TemplateKlass>
  class custom_class {
  private:
   TemplateKlass x, y;
  public:
   custom_class(TemplateKlass, TemplateKlass);
  };
  

I am will not into details, As there are far better resources

Function as Argument:

We can pass a function in the argument of another function, Well Actually A function pointer is passed to be exact. This comes in handy in the situation, where you have multiple services for the same request, for example, Hashing, you can use so many third-party algorithms for hashing.

bool verify_hash(std::string (*hash_func)(std::string)){
    /*
        This will take in any function with
        input and output as a string 
    */
    return hashed_output == hash_func(input)
}

Inheritance

I picked up this in my Unity3D days, In Unity3D Almost everything is inherited and then used.

The plan is simple, Create a class with a bunch of public members all throwing error.

And Then Everyone would have to Inherit that class and override it.

For Example

class base_class{
    /*
        Everyone will inherit from this class
    */
public:
    base_class(){}
    base_class(float) {throw not_implemented_exception();}

    virtual operator string() const = 0;

    bool operator<(const base_class &other) const { throw not_implemented_exception(); }

    template <typename TemplateKlass>
    void some_func(TemplateKlass temp) {throw not_implemented_exception();}
}

class extended_class : public base_class{
    /*
        This is how Inheritance would work
    */
private:
    float m_temp;
public:
    extended_class(){}
    extended_class(float t_temp) : m_temp(t_temp)

    operator std::string() {return to_string(t_temp);}

    bool operator<(const extended_class &other) const { m_temp < other.m_temp }

    template <typename TemplateKlass>
    void some_func(TemplateKlass temp) {...}
}

Bonus: Icon Pack!

Yeah... I created my own icons too...

Here we go!

function quine() { console.log(quine.toString()) }

The key here is that any function in JavaScript can be converted into a string and can be printed. Also, console.log is not the only option, alert can be used too. Although it will not work in a node terminal.

Above is a function that prints its source code but it is not a file that can be executed. So let's add a Call statement,

function quine() { console.log(quine.toString()+" quine();") } quine();

Note that we needed to add something extra in the log statement to achieve our goal. And ; was probably not needed.

Let's make it a little elegant, We know that JavaScript can make a function run as soon as it is defined, By using an IIFE (Immediately Invoked Function Expression).

( function quine() { console.log("( " + quine.toString() + " )()") } )()

Note that we manipulated the log statement as required.

For some more Quines in NodeJS: https://catonmat.net/quine-in-node

Now let's take Arrow-Operator and Format-Strings into this equation and It becomes almost eye-blindingly beautiful!

($=_=>`($=${$})()`)()

To Understand let's remove IIFE and extra parentheses in the format-string. And also, add some spacing.

$    =    _    =>    `$=${$}`

So, the first $ is a variable that contains an arrow function. _ is a random parameter for the arrow function which remains unused. After the arrow, this is our format-string which can be divided into 2 parts, the String, "$=", and the Variable which is first $ itself.

Lastly, A Quine needs to be executable but it doesn't mean that programs resulting in errors can't be a Quine. Here is an example

throw 0
^
0

Link: https://github.com/nmrugg/quine

This program when executed as a .js file with the help of NodeJS outputs its own source code.

How this works is, NodeJS returns an error at the first line, the rest of the code is how the error looks like.

If you make your own JS Quine or you want to share Quine in other programming languages, then please do write in the comment section.

Draw Graphs in C++ I was looking for a graphics.h project, One day my friend asked me "Did you ever come across any code which Draws the given input graph?", I replied... wait-for-it! Link: https://github.com/ra101/graphical-representation-of-graphs-in-cpp

Pinger (Python) One of my deployed college project got shut down. This Script executes at startup, starts a headless browser, and open the various sites declared within. All in the background. Link:https://github.com/ra101/pinger

lbry VLC Extension (Lua) I was looking for a dark theme for VLC and I found out that people can create extensions that can be attached to the final build binary! This extension enables us to network streams free lbry.tv videos. Link: https://github.com/ra101/lbry.tv-VLC-Playlist-Parser

Text to Morse Code (Dart) A Flutter Trial App, It changes Text to Morse Code and then allows to vibrate the phone or to flicker torch accordingly. Link: https://github.com/ra101/txt_mrs_vib

DuckDuckGo Chrome-Ext (JavaScript) A Chrome-Extension that adds a button to open the current search with DuckDuckGo. You can also attach a Key-Binding to use it. Link: https://github.com/ra101/DuckDuckGo-Chrome-Ext