DEV Community: Parth Agarwal

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Parth Agarwal — Wed, 14 Jan 2026 07:40:40 +0000

Parth Agarwal

Jan 14

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

#linux #opensource #devops #programming

Comments

7 min read

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Parth Agarwal — Wed, 14 Jan 2026 07:37:27 +0000

Parth Agarwal

Jan 14

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

#linux #opensource #devops #programming

Comments

7 min read

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Parth Agarwal — Wed, 14 Jan 2026 07:36:39 +0000

Transferring files between your local machine and a virtual machine (VM) is one of the most common tasks in tech. We often use scp because it comes natively installed and has similar utilization to ssh, but it is the clunkiest tool for the job.

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:

SSH (Secure Shell) Tools
1.1 SCP (Secure Copy)
1.2 SFTP (SSH File Transfer Protocol)
1.3 SSHFS (SSH Filesystem Mount)
Rsync
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.

Protocol	Encrypted	Resumable
SSH	Yes	No

# 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).

Protocol	Encrypted	Resumable
SSH (subsystem)	Yes	Yes

# 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.

Protocol	Encrypted	Resumable
SSH (with FUSE)	Yes	N/A

# 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.

Protocol	Encrypted	Resumable
SSH (default) or native TCP daemon	Yes (if over SSH)	Yes

# 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.

Protocol	Encrypted	Resumable
HTTP	No	No

# 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.

Protocol	Encrypted	Resumable
HTTP	No	Yes (client-dependent)

# 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).

Protocol	Encrypted	Resumable
HTTP/HTTPS	Optional (HTTPS)	Yes

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.

Protocol	Encrypted	Resumable
HTTPS	Yes	Yes

# 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

SSHFS: High latency per operation, every read/write is a round-trip over SSH.
SCP/SFTP: SSH encryption overhead, single-threaded.
Rsync over ssh: Efficient delta transfers and compression.
HTTP Single-Threaded: Direct HTTP with no encryption overhead.
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.

Alias Alchemy - Instant Bash Setup!

Parth Agarwal — Wed, 13 Aug 2025 18:35:33 +0000

Alias Alchemy - Instant Bash Setup!

Parth Agarwal ・ Aug 13 '25

#bash #linux #opensource #kubernetes

Alias Alchemy - Instant Bash Setup!

Parth Agarwal — Wed, 13 Aug 2025 18:34:36 +0000

Alias Alchemy is a Deno-powered server that fetches aliases from a GitHub repository based on your query. Think of it as your instant alias spellbook, perfect for setting up new environments in seconds.

⚡ 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 ?

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.
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.
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

AI Hallucinations: A Future Full of Misconceptions and Mediocre Code

Parth Agarwal — Sat, 04 May 2024 15:30:35 +0000

Reader discretion is advised!
A good Sus-Saturday to all. In this article, I drag and drown
you with my paranoia about AI. Let the mass psychosis begin!

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?

Boost your Git Squash-Rebase Workflow with these Commands! (auto-squash, auto-commit, auto-rebase, auto-push)

Parth Agarwal — Thu, 17 Aug 2023 07:51:01 +0000

I recently joined a company, that follows squash-rebase flow here, and as my Git KT was going on, I figured I should build these commands before actually starting development, now that I have started development, these turned out to be quite handy!

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!

AR Portfolio App

Parth Agarwal — Thu, 07 Apr 2022 13:40:21 +0000

A Personalized Visiting Card that floats in AR space.

source_code, documentation, download: https://ar.ra101.dev

AR Card | AR Portfolio App

Parth Agarwal — Thu, 07 Apr 2022 13:33:37 +0000

A Personalized Visiting Card that floats in AR space.

source_code, documentation, download: https://ar.ra101.dev

How to Write a C++ Library

Parth Agarwal — Tue, 22 Feb 2022 21:24:08 +0000

Prerequisite: One must be familiar with coding in C++.

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

@pauljlucas suggested:

You really should use something like GNU Automake or CMake instead of hand-written makefiles.

These tools may add 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 line-space between them.
- First, for core g++ system files.
- Second, for externally added libraries.
- Third, for locally created files.

@pauljlucas suggested:

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

By "self-sufficient", Xe means, local headers are not depending on System or External libraries of this file.
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 : 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...

GNU Extension	Preview	Download
.c	c.png	c.ico
.cpp	cpp.png	cpp.ico
.cs	cs.png	cs.ico
.h / .hpp	h.png	h.ico

If you think I have missed something or you have other coding style or some advice, do let me know, I might append to this post. Make it one central point of all information.

namespace ra :: BlockChain as STL, Data Structure and Iterators

Parth Agarwal — Tue, 22 Feb 2022 17:40:04 +0000

Aim:

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)

# 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)

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))

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:

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 <typename EncryptionAlgo>
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))

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:
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_chain 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

namespace ra :: RSA Cryptography

Parth Agarwal — Fri, 28 Jan 2022 14:10:59 +0000

Aim:

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

DEV Community: Parth Agarwal

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

Beyond SCP: Mastering VM File Transfers with Rsync and HTTPS Accelerators

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.4 HTTPS File Server with Basic Auth (Caddy)

Security Considerations

Performance Comparison: Slowest to Fastest

My Daily Workflow

Alias Alchemy - Instant Bash Setup!

Alias Alchemy - Instant Bash Setup!

Parth Agarwal ・ Aug 13 '25

Alias Alchemy - Instant Bash Setup!

⚡ Usage:

🤔 Why I built it ?

📖 Help Guide:

AI Hallucinations: A Future Full of Misconceptions and Mediocre Code

Boost your Git Squash-Rebase Workflow with these Commands! (auto-squash, auto-commit, auto-rebase, auto-push)

What is Git Squash-Rebase Workflow?

Git Squash (gsq):

Git Auto Commit (gac):

Git Fetch Rebase (gfrb):

Git Upstream Push (gup):

AR Portfolio App

AR Card | AR Portfolio App

How to Write a C++ Library

File Types:

makefile:

PreProcessors:

Nomenclature:

File | namespace | Class | function:

Template Parameter:

Constants | Macros:

Variables:

Taboo of Naming:

Comments:

Custom Exceptions:

Modularity

Template

Function as Argument:

Inheritance

Bonus: Icon Pack!

namespace ra :: BlockChain as STL, Data Structure and Iterators

Aim:

Blockchain in Brief:

Scope of this Project:

Plan of Attack:

Setup

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

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

base_transaction<EncryptionAlgo>

custom_transaction : public base_transaction<EncryptionAlgo>

block <Transaction, HashFunctionClass>

block_chain <Transaction, HashFunctionClass>

namespace ra :: RSA Cryptography

Aim:

What is RSA?

How RSA Works?

Code:

Constructors:

create_key(seed) function,

encrypt(digest, key) function,

decrypt(encrypted_data) function,

padding(string str) function,

encrypt_with_padding(digest, key) function,

decrypt_with_padding(encrypted_data) function,

sign(Message message) function,

verify(Message message, digest, others_public_key) function,

Git Squash (`gsq`):

Git Auto Commit (`gac`):

Git Fetch Rebase (`gfrb`):

Git Upstream Push (`gup`):

`makefile`:

File | `namespace` | `Class` | `function`:

`Template` Parameter:

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

`base_transaction<EncryptionAlgo>`

`custom_transaction : public base_transaction<EncryptionAlgo>`

`block <Transaction, HashFunctionClass>`

`block_chain <Transaction, HashFunctionClass>`

`create_key(seed)` function,

`encrypt(digest, key)` function,

`decrypt(encrypted_data)` function,

`padding(string str)` function,

`encrypt_with_padding(digest, key)` function,

`decrypt_with_padding(encrypted_data)` function,

`sign(Message message)` function,

`verify(Message message, digest, others_public_key)` function,