DEV Community: Indira Kumar A K

Why self-assessment is broken (and how I fixed it with binary evidence)

Indira Kumar A K — Tue, 10 Mar 2026 18:31:03 +0000

The Problem

Last month I tried to honestly assess my skills as a solopreneur. The standard approach: list your skills, rate them 1-5.
I gave myself a 4 on SEO. Felt right. I've posted blogs, improved rankings, added valid tags.
Then I started asking specific questions:

Have I ranked a page on Google’s 1st page? No.
Have I done keyword research + published optimized content? No.
Have I intentionally built backlinks? No.

That 4 was a fantasy. Dunning-Kruger in action, we overrate the skills we're weakest at because we don't know enough to know what we don't know.

The Insight

The fix is simple: replace "how good am I?" with "what have I actually done?"
Instead of a 1-5 scale on "SEO," use binary checkpoints:

Done keyword research and published optimized content?
Ranked a page on Google's first page?
Built backlinks intentionally?

Binary. No room for ego. You either have the evidence or you don't.

What I Built

I turned this into proofwork, an evidence-based skill tracker for solopreneurs.
It maps ~85 concrete checkpoints across 4 pillars:

Think - Are you validating before building? Do you have a pricing strategy? Are you tracking metrics?

Build - Can you ship frontend, backend, and infrastructure? Are you using AI and automation to multiply your output?

Sell - Can you write copy that converts? Do you understand SEO? Can you build an audience?

Sustain - Do you have your legal and financial house in order? Are you managing your energy sustainably?

The Feature That Made It Useful

The app lets you export your current state as a JSON file: proofwork-2026-03.json.
Fill it out again in 3 months. Load the old snapshot. Hit Compare.
You get a full diff - what evidence you gained, what you lost, per-pillar progression with percentage deltas. This turns a one-time exercise into a longitudinal growth tracker.

Other features:

Share your map via URL (state encoded in hash, no server needed)
Gap analysis view auto-ranks your weakest skills
Radar visualization across all branches
Notes field for reflections (saved in the JSON)
100% client-side — your data never leaves your browser

My Results

After filling it out honestly:

Build: ~79% - good, but gaps in testing
Sell: ~28% - almost nothing proven
Think: ~28% - had never validated an idea properly
Sustain: ~55% - no business entity, but good bookkeeping

I was spending 90% of my time in the one pillar that was already my strongest (build). The classic technical founder trap.
Try It

Free, open source, no account needed: skillsmap.indirakumar.com

The gaps it reveals might surprise you. They surprised me

Var vs Let vs Const keyword in JavaScript

Indira Kumar A K — Tue, 03 Jan 2023 18:00:47 +0000

Introduction

Let vs Const vs Var is one of the oldest rivalries in JavaScript. This is a small article explaining the difference between all of them. Before going any further remember in JavaScript we have only function scope (the declarations are accessible only inside the declared block) and block scope (the declarations are accessible only inside the declared block). If anything is being declared outside all the blocks and functions, then it takes global scope.

var Keyword

var keyword takes function scope/global scope, which means a variable declared inside some other block is accessible anywhere in the code.

Example

if (true) {
  var varVariable = "This is true from var";
}
console.log(varVariable);

Output:

This is true from var

We can access this varVariable outside the block as well. As well as you can redeclare the same variable again, this will overwrite the previously declared variable.

if (true) {
  var varVariable = "This is true from var";
}
varVariable = "This is var variable outside the block";
console.log(varVariable);

Output:

This is var variable outside the block

Note:
variables created using var keyword are hoisted. If you are new to hoisting, then I would suggest you to see this video for better clarity.

let Keyword

The let keyword has block scope, which means it has scope only within the block it is declared and can not be accessed outside its block.

if (true) {
  let letVariable = "This is true from let";
}

console.log(letVariable);

Output:

ReferenceError: letVariable is not defined

But within the block it is accessible.

if (true) {
  let letVariable = "This is true from let";
  console.log(letVariable);
}

Output:

This is true from let

Also if you mistakenly try to redeclare a let keyword variable error will be thrown, because let keyword variables can be declared only once.

if (true) {
  let letVariable = "This is true from let";
  let letVariable = "This is second declared true from let";
  console.log(letVariable);
}

Output:

SyntaxError: Identifier 'letVariable' has already been declared

But you can re-assign values of letVariable.

if (true) {
  let letVariable = "This is true from let";
  letVariable = "This is re-assigned true from let";
  console.log(letVariable);
}

Output:

This is re-assigned true from let

const Keyword

const keyword variables are very similar to let keyword, it has the same block scope. It doesn't allow you to redeclare variables. It also doesn't allow re-assigning new values. However, if you have declared an object with const keyword, Its properties can be changed.

const constVar = { name: "Kumar" };

constVar.name = "Indira";
console.log(constVar);

Output:

{ name: 'Indira' }

Conclusion

It is always advised to use const and let as best practices. cont keyword, when you won't or don't accidently wanna re-assign new values to your variable. Use let keyword when you want to re-assign values to your variable.

Reference

Function Composition Vs Inheritance

Indira Kumar A K — Mon, 02 Jan 2023 10:44:34 +0000

Introduction

Function Composition is pretty much one of the most interesting topics in JavaScript Development. Every single math student would have come across composition in your Set Theory chapter, this function composition is similar to that. The main use case of function composition is that it helps us write clean code and makes the best use of the available code. Let us see why this is better than other approaches.

Inheritance

Let us see a situation where you have to create a video game with monsters. An ideal idea anyone would come up with is, to create a Monster class and use OOP concepts.

class Monster {
  constructor(name) {
    this.name = name;
  }
  attack() {
    console.log(`${this.name} attacked`);
  }
  walk() {
    console.log(`${this.name} walked`);
  }
}
class FlyingMonster extends Monster {
  fly() {
    console.log(`${this.name} flew`);
  }
}
class SwimmingMonster extends Monster {
  swim() {
    console.log(`${this.name} swam`);
  }
}

const bear = new Monster("bear");
bear.walk;
bear.attack();
const eagle = new FlyingMonster("eagle");
eagle.walk();
eagle.attack();
eagle.fly();
const shark = new SwimmingMonster("shark");
shark.walk();
shark.attack();
shark.swim();

Output:

bear walked
bear attacked
eagle walked
eagle attacked
eagle flew
shark walked
shark attacked
shark swam

Here flying monster and swimming monster are inherited from the parent monster class. Imagine a situation where you have to create a flying swimming monster.

You would inherit swimming monsters in your new class and create a copy of fly() function.

class FlyingSwimmingMonster extends SwimmingMonster {
    fly() {
      console.log(`${this. name} flew`)
    }
}

But this will not be efficient in a large codebase because the fly function is repeated and redundant. So to solve this problem. We have a very good approach in functional programming.

Functional Programming

//Functional Programming approach
// Destructuring the needed parameters for the function then returning a variable that points towards the function
function swimmer({ name }) {
  return {
    //here the arrow function will take teh paramater that swim function will take during the function call.
    swim: (speed) => console.log(`${name} swam with speed ${speed}`),
  };
}
function attackerAndwalker({ name }) {
  return {
    attack: () => console.log(`${name} attacked`),
    walk: () => console.log(`${name} attacked`),
  };
}
function flyer({ name }) {
  return {
    fly: () => console.log(`${name} flew`),
  };
}

function swimmingMonsterCreator(name) {
  const monster = { name: name };
  return {
    // using the spread operator here, we can add any new function to the object that is beaing created.
    ...monster,
    ...swimmer(monster),
    ...attackerAndwalker(monster),
  };
}
function flyingSwimmingMonsterCreator(name) {
  const monster = { name: name };
  return {
    ...monster,
    ...swimmer(monster),
    ...flyer(monster),
    ...attackerAndwalker(monster),
  };
}

const Dragon = flyingSwimmingMonsterCreator("Toothless");
Dragon.attack();
Dragon.swim(45);
Dragon.fly();

Output

Toothless attacked
Toothless swam with speed 45
Toothless flew

Here as you can see, each individual function has been coded in such a way that they can be spread using the "spread operator" wherever needed.

Conclusion

Functional programming is more suited for large code bases, where you want redundant code to be much less. Whereas, Object Oriented programming is more suited when you want your logic to be well segregated and preserved. I would really suggest you to read hacker noon's blog on function decomposition, because that gives more use cases on where it can be used.

Reference

Pure vs Impure Functions in JavaScript

Indira Kumar A K — Sun, 01 Jan 2023 09:37:44 +0000

Introduction

We have reached a day where we are classifying functions as pure and impure. If this is the first time you are hearing this term. Then there is a huge chance you are wondering what "pure function" is on earth. This article focuses on explaining the difference between pure and impure functions and what is observable side effects.

Pure Functions

The definition of a pure function is that:

The function always returns the same result if the same arguments are passed in. These functions do not access or modify variables outside of their scope, which means it does not depend on any state or data and only depend on their input arguments.
They do not cause side effects (such as network requests, logs, or state changes).

Any function that satisfies the above two conditions can be deemed as a pure function. Now you might wonder what a side effect is, let's dig deep into that.

Side Effects

A side effect is any interaction with the outside world from within a function. That could be anything from changing a variable that exists outside the function, to calling another method from within a function.

Note: If a pure function calls a pure function this isn’t a side effect and the calling function is still pure.

Side effects include, but are not limited to:

Making an HTTP request
Mutating data
Printing to a screen or console
DOM Query/Manipulation
Generating a random number (Math.random())
Getting the current time

Side effects do not mean they are bad, many a times, we require them. But when a function is needed to be pure, it should not contain any side effects.

Pure Function Example

For demonstration purposes here is an example of a pure function that calculates the percentage of marks obtained out of 100.

function percentage(obtainedMarks, totalMarks) {
 return (obtainedMarks/totalMarks)*100;
}

It passes both 1, and 2, of the requirements for a function to be declared pure. It doesn’t depend on any external input, it doesn’t mutate any data and it doesn’t have any side effects. This function will always and always generate the same result no matter what.

Impure Functions

Now let's take a look at what an impure function is.

let totalMarks = 100;
function percentage(obtainedMarks) {
 return (obtainedMarks/totalMarks)*100;
}

Here you can observe that the return value will change according to the change in an outside variable.

Why Are Pure Functions Important In JavaScript?

Pure functions are used heavily in Functional Programming. And, libraries such as ReactJS and Redux require the use of pure functions.

Not all functions need or should be pure. A button press event handler that modifies the DOM, for instance, is not a good fit for a pure function. However, using other pure functions from the event handler will cut down on the number of impure functions in your application.

Another reason to use pure functions where possible is testing and refactoring.

One of the major benefits of using pure functions is they are immediately testable. They will always produce the same result if you pass in the same arguments.

Additionally, they make it much simpler to maintain and refactor code. A pure function can be changed without worrying about unforeseen consequences messing up the entire application and sending you to debugging hell.

So simply put, pure functions are an absolute way to have clean code and its a best practice to have

Reference:

https://jsfunctions.io/pure-versus-impure-functions

Arrays in JavaScript

Indira Kumar A K — Wed, 14 Dec 2022 06:55:51 +0000

Introduction

Arrays are list-like objects with prototypes having their functions for traversal and mutation. In JavaScript, both the data types and the array length are not fixed, unlike many other programming languages. Let us see the important characteristics of arrays in JavaScript.

Characteristics

JavaScript arrays are resizable and can contain a mix of different data types. (When those characteristics are undesirable, use typed arrays instead.)
JavaScript arrays are not associative arrays and so, array elements cannot be accessed using arbitrary strings as indexes, but must be accessed using nonnegative integers
JavaScript arrays are zero-indexed: the first element of an array is at index 0
JavaScript array-copy operations create shallow copies.

Properties:

The length property indicates how many elements an array has.

var arr = ['a', 'b'];
arr.length //2

The in operator works for arrays, too:

var arr = [ 'a', 'b', 'c' ];
1 in arr // is there an element at index 1? true

Arrays are objects and can thus have object properties:

var arr = [];
arr.foo = 123;
arr.foo //123

Note:
While it's certainly possible to add object properties to your array, it's not something that you would normally want to do and it's important to note that object properties will not be included in any methods or functions which enumerate the array's values.
Example:

const myArray = ["a", "b", "c"]
myArray.foo="bob"
console.log(myArray) // [ 'a', 'b', 'c', foo: 'bob' ]
console.log(myArray.map(i => i)) // [ 'a', 'b', 'c' ]

Array Methods:

Arrays have many methods (see Array Prototype Methods). Here are a few examples:

var arr = [ 'a', 'b', 'c' ];

arr.slice(1, 2)  // copy elements [ 'b' ]
arr.slice(1) // [ 'b', 'c' ]

arr.push('x')  // append an element 4
arr // [ 'a', 'b', 'c', 'x' ]

arr.pop()  // remove last element 'x'
arr
[ 'a', 'b', 'c' ]

> arr.shift()  // remove first element
'a'
arr //[ 'b', 'c' ]

arr.unshift('x')  // prepend an element 3
arr //[ 'x', 'b', 'c' ]

arr.indexOf('b')  // find the index of an element 1
arr.indexOf('y') -1

arr.join('-')  // all elements in a single string 'x-b-c'
arr.join('') // 'xbc'
arr.join()
'x,b,c'

Iterating Over Arrays

There are so many methods to iterate through an array. But here we will see "forEach", "filter", and "map".

forEach iterates over an array and hands the current element and its index to a function:

[ 'a', 'b', 'c' ].forEach(
    function (elem, index) {  // (1)
        console.log(index + '. ' + elem);
    });

The preceding code produces the following output:

0. a
1. b
2. c

Here you can just take the elements as well by giving only elem as the parameter to the function.

map returns a new array by applying a function to each element of an existing array:

[1,2,3].map(function (x) { return x*x })
[ 1, 4, 9 ]

Array.prototype.filter(callback, thisValue?)
The output array contains only those input elements for which the callback returns true. For example:

[ 1, 0, 3, 0 ].filter(function (x) { return x !== 0 })
[ 1, 3 ]

There are two more functions in iterating over arrays,
They are:

group()
Groups the elements of an array into an object according to the strings returned by a test function.
groupToMap
Groups the elements of an array into a Map according to values returned by a test function.
Note:
The group() and groupToMap() functions are experimental only and is currently not supported in any web browsers.

Thank you so much❤️ @gilfewster, @dannyengelman for your valuable suggestions.

Reference

A Comprehensive Course on GitHub

Indira Kumar A K — Mon, 21 Nov 2022 11:55:53 +0000

Introduction

If you are a person who even in the wildest of dreams wants to be a software developer, then Git is the first thing I would recommend you to learn. Git is a version control system, and GitHub is one of the different tools available to do it.

Technical terms aside, Have you ever collaborated with different people for working on the same code, and then every time you make a change, you compress it and send the zip file to the other and use it? Such a painful way of informing changes to others right, Professionals reading this would really wonder, but not gonna lie, this is how 80% of my university students exchanged code in their freshmen year. If you have ever faced any similar issues in your coding life, then you are in the right place to improvise yourself.

If you are a conventional person who wants to all kinds of version control systems and their use cases, then you can read this article(Version Control Systems) and come back to this article, Or if you are the kind of person who just wants to go work instead of reading pages of theory, then you can continue reading the current article.

Prerequisite

All the best❤️ for your new venture, I am sure this would definitely change the way you manage your code among teams after finishing this course. First of all, before starting go to git-it repository and download the entire repository, then run the .exe file to open a small application through which you would learn to use GitHub.

You would have the following challenges to complete and learn git through those challenges.

Image Credits: git-it

How to Approach:

I have divided the course challenges into 5 days for the sake of simplicity and to avoid overkill. It is up to you to complete however much you would like to do. I would suggest you to go ahead with one day at a time for 5 days, but if you think you are faster, then you can obviously finish it in one sitting💯💯.

Day 1:

Get Git:

Git is free open-source software (the source code is public) written by Linus Torvalds who also wrote the Linux operating system's kernel.
I recommend installing Git by installing the GitHub desktop app
This is the best way to install git bash on your computer, especially if you are a beginner. And also, don’t forget to select “add git bash in Windows Explorer Integration”

Image Credits: git-it

Now open git from the start menu.
Steps:
1) You can Set your name using:

git config --global user.name "Your Name"

2) Now set your email:

git config --global user.email "youremail@example.com"

Repository:
You can imagine it as a project folder with all the relevant files inside of it. Sometimes they're called "repos" in short.
You tell Git what your project is, and Git will start tracking all the changes to that folder. This makes it a Git repository: A folder of items being tracked by Git. Git tracks when files are added, subtracted, or even a single letter in a single file
You will use Command Line Interface (CLI) to work on Git since that is the most efficient way to get things done once you master it. The first part of the command lets your computer know you're talking to Git. The parts following that are the commands and the different options you want Git to act on.

Navigate to your preferred folder and right-click (select more options), then chose open with git bash.

Steps:
1) First, make a new folder:
Tip: mkdir stands for make directory

mkdir hello-world

2) Then go into that folder:
Tip: cd stands for change directory

cd hello-world

3) Finally, tell Git to initialize (start tracking) the folder you are now in:

git init

The last command should return something starting with "Initialized empty Git repository". This is the way of telling git that this is my project folder and to take care of all the changes here. Git will create a hidden folder and use that to track all the changes in this ‘hello-world” folder.

Day 2:

Commits:
Commits are core to using Git. They are the moments in which you save and describe the work you've done, using commit messages.
Simply put, a commit is a point of history in your folder, every commit will have an id attached to it, which you can use to revert to that point of history in your folder, more on this later.
Navigate to your hello world folder, right-click (select more options), then chose open with git bash.

Steps:
1) Create a new file using notepad and save it as readme.txt in your hello world folder.

2) You can check the status of the folder using:

git status

Git should tell you that a file has been added.

3) Then add these files to the stage(only after this, we can commit any of our changes) using the following command:

git add readme.txt

Why add a command? In real-time, so many files are changed in our repository. But we might not want all of them to be saved in our commit. We would want only a few file changes to be saved in history. So using this add command, we can add all the files which we would like to save in our commit.

4) Finally, commit those changes to the repository's history with a short (m) message describing the updates.

git commit -m "Created readme"

whatever is followed after -m is your commit message. It is always advised to put meaningful commit messages. Not “advasdma”. Trust me good commit messages save you tonnes of time if ever your application goes wrong somewhere.

5) Now add another line to 'readme.txt' and save the file again.
In the terminal, you can view the difference between the file now and how it was at your last commit.
Tell Git to show you the diff:
git diff

Image Credits: git-it

Githubbingggg:
The repository you've created so far is just on your computer, which is handy but makes it pretty hard to share and work on with others. No worries, that's what GitHub is for!
GitHub acts as the central repository for you and everyone else to share. You push your changes to it and pull down changes from others.

Steps:
1) Create a GitHub Account
Visit github.com and sign up for a free account. High five, welcome!

Remote:
When you put something on GitHub that copy lives on one of GitHub's servers. This makes it a remote repository because it is not on your computer, but on a server, "remote" and somewhere else. By pushing your local (on your computer) changes to it, you keep it up to date.

Image Credits: git-it

Steps to create a remote Repo:
• Go to github.com, log in, and click the '+' in the top right and then click 'New repository'.
• Give it a name that matches your local repository's name, 'hello-world', and a short description.
• Make it public. This means it'll be listed on your public profile.
• Don't initialize with a README because we already have a file, locally, named 'readme.txt'. This is a helper option from GitHub if you hadn't already made it.
• Leave '.gitignore' and 'license' set to 'none'. We won't use them in this tutorial.
• Click create repository!

Note:

A readme explains what the project is, how to use it, and oftentimes, how to contribute (though sometimes there is an extra file, 'CONTRIBUTING.md', for those details).
A .gitignore is a list of files that Git should not track, for instance, files with passwords!
A license file is the type of license you put on your project. This lets others know how they can use it. Information on the types is here: choosealicense.com.

Now, at the top you'll see 'Quick Setup', make sure the 'HTTPS' button is selected and copy the address—this is the address of your repository on GitHub's servers.
Back in your terminal, and inside of the 'hello-world' folder that you initialized as a Git repository in the earlier challenge, you want to tell Git to remember the address of the remote version on GitHub's servers. You can have multiple remotes, so each requires a name. The primary remote is typically named origin.

To add a remote named 'origin' to your repository:

git remote add origin <URLFROMGITHUB>

Note for Windows users:
If you have GitHub Desktop on your computer, a remote named 'origin' is automatically created in your local repository. In that case, you'll just need to tell it what URL to associate with 'origin'. Use this command instead of the 'add' one above:

git remote set-url origin <URLFROMGITHUB>

Next, you want to push (send) everything you've done locally to your remote repository on GitHub.

Git has a branching system so that you can work on different parts of a project at different times. We'll learn more about that later, but by default, the first branch is named 'master'. When you push (and later pull) from a project, you tell Git the branch name you want and the name of the remote that it lives on.

Push:
Next, you want to push (send) everything you've done locally to your remote repository on GitHub. Git has a branching system so that you can work on different parts of a project at different times. We'll learn more about that later, but by default, the first branch is named 'master'. When you push (and later pull) from a project, you tell Git the branch name you want and the name of the remote that it lives on.
In this case, we'll send our branch named 'master' to our remote on GitHub named 'origin'.

git push origin master

Image Credits: git-it

Day 3:

Forks:
So far, we have seen how to use git to manage your repo. Now we will see a fork which is interacting with other people’s repo.
When you fork a repository, you're creating a copy of it on your GitHub account. Your forked copy begins its life as a remote repository—it exists just on your GitHub account, not on your computer. Forks are used for creating your own version of a project or contributing back your changes (such as bug fixes or new features) to the original project.

Image Credits: git-it

Clone Your Fork Locally
Now, in the terminal, you'll clone the repository onto your computer.
Back out of your 'hello-world' folder:
Tip: the two dots mean to step out of a directory one level

cd ..

Now, clone your fork:

git clone <URLFROMGITHUB>

here

git clone https://github.com/Indira-kumar/patchwork.git or 
git clone https://github.com/jlord/patchwork.git

Go into the folder it created for your local copy of the fork (in this case, named 'patchwork').

cd <FOLDERNAME>

Type git remote -v to see that the address to the fork is already set up.

Connect to the Original Repository
You can name this remote connection anything you want, but typically people use the name 'upstream'; let's use that for this.

git remote add upstream https://github.com/jlord/patchwork.git

To be sure you have the correct remotes set up, type git remote -v to list out the addresses you have stored. You should have an 'origin' remote with your fork's address and then an 'upstream' remote with the address to the original, the URL noted above in this step.

Branches:
It's common practice when working on a project or with others on a project to create a branch to keep your working changes in. This way you can do your work while the main, commonly named 'master', branch stays stable. You can even create a branch for a branch.

Image Credits: git-it

When you create a branch, Git copies everything from the current branch you're on and places it in the branch you've requested be made.
Branches are case-sensitive so name your branch exactly the way your GitHub name appears.

git branch <BRANCHNAME>

To go into that branch and work on it you checkout a branch. Go to your new branch:

git checkout <BRANCHNAME>

Now make changes as you wish in your local repository and then while pushing you get to choose which remote and which branch you want to push to.

git push origin <BRANCHNAME>

Image Credits: git-it

Day 4:

Collaborators are other GitHub users who are permitted to make edits to a repository owned by someone else.
Contributor, this describes another GitHub user who has made contributions, through a Fork and Pull Request, to a project.
The URL should look like this, but with your username.
github.com/YOURUSERNAME/patchwork/settings/collaboration
Here in your repository right now, you can add reporobot as a collaborator.

Pulling from a Remote:
If you're working on something with someone else, you need to stay up to date with the latest changes. So, you'll want to pull in any changes that may have been pushed to the central GitHub repository.

Image Credits: git-it

Use the following command to make changes to the local code:

git pull <REMOTENAME> <BRANCHNAME>

Day 5:
Pull Requests:
when you make changes and improvements to a project you've forked, you'll want to send those changes to the maintainer of the original and request that they pull those changes into the original so that everyone can benefit from the updates—that's a pull request.
https://opensource.com/article/19/7/create-pull-request-github

Merge Locally:
First, move into the branch you want to merge into—in this case, the branch 'gh-pages'.

git checkout gh-pages

Now tell Git what branch you want to merge in—in this case, your feature branch that begins with "add-".

git merge <BRANCHNAME>

Tidy up by deleting your feature branch. Now that it has been merged you don't really need it around.

git branch -d <BRANCHNAME>

Image Credits: git-it

Note:

git rm - -cached <FILENAME>

To remove the files from the stage (from the track)
Git merge tool
To manage merge conflicts, and merge hassle-free (winmerge is popular)

Git stash
When you are working on a particular branch (branch A), you are not yet done with changes made, so you don’t want to commit your changes, but you have to switch to another branch (branch B) for some change. Then to keep to changes in branch A without committing you would use “git stash”.
Then now you can switch to branch B, and make your changes and commits, and when you come back to branch A for working, you can do “git stash apply” to bring back those unsaved changes

Here is a video for an in-depth definition.

Congratulations on completing the basic GitHub course, now you can go for more advanced topics like rebase, force push etc. in this course

References:

Learn Git in 20 mins
Git-it project - This course is based on this software. Credits to jlord for such amazing content.
CS50 GitHub

Thank You So much for your time!! Happy Coding❤️

Version Control System

Indira Kumar A K — Mon, 21 Nov 2022 09:20:20 +0000

What is version control?

Version Control or Source Control (known as VCS) helps you track and manage the software code. As teams get bigger and bigger, development happens faster and faster and so we need a reliable way to track the changes and maintain different versions of our software, that’s where Git and Version control come into the picture.

Why Version Control:

1) History of Changes:
Complete long-term change history of every file is saved in git. This means every change made by many individuals over the years. Changes include the creation and deletion of files as well as edits to their contents. Different VCS tools differ in how well they handle the renaming and moving of files. This history should also include the author, date, and written notes on the purpose of each change (commit messages). So, reverting to older code at any given time would be possible.

2) Branching & Merging:
different people working on different parts of the software is very common, which leads us to the problem of not being able to merge it together leading to unimaginable complexities. For example, let's take Git is not available, and so we would have to make a zip file and send it to all our teammates for any code changes we make, imagine how hard it would be to download and merge those files with theirs. But with git and its features, it is easy to branch different features and merge them when needed.

3) Traceability:
All the changes being saved along with the purpose of change messages helps in bug analysis and other forensics. we can also deploy famous bug-tracking software like JIRA etc.

Two Types of Architecture:

Centralized:
A centralized VCS has a remote central instance and if that is lost, it can cause data loss and can cause productivity issues.
Distributed:
A distributed model architecture avoids these pitfalls by keeping a full copy of the source code at each VCS instance.
Git and mercurial are DVCS

The difference between a repository hosting services and a version control system:
they are two separate entities. VCS is a low-level command-line-based interface that helps track the changes in your file
Repository hosting services are third-party web applications that wrap and enhance a version control system. And that is where CI/CD pipeline integration etc. can be implemented.

References:

Thank you for your time!! Happy Coding❤️

A Thorough View of Strings in JavaScript

Indira Kumar A K — Sat, 19 Nov 2022 08:43:36 +0000

Introduction

In JavaScript, textual data is stored as strings. There is no separate type for a single character.
The internal format for strings is always UTF-16, no matter what the pages use. The size of a JavaScript string is always 2 bytes per character. Any string can be created by enclosing the value with single or double quotes or backticks.

Example:

let single = 'single-quoted';
let double = "double-quoted";
let backticks = `backticks`;

Here single and double quotes are the same. But backticks help us embed expressions into strings by just wrapping ${} around

alert(`1 + 2 = ${1 + 2}.`); \\ 1 + 2 = 3.

Backticks also allow you to span your texts to multiple lines which is not the same case with quotes.

let studentsList = `Guests:
 * Indira
 * Suraj
 * Valli
`;

Tagged Templates:

Backticks are a blessing in another way too. You can use them to format strings using template functions. Here is an example explaining the same

const person = "Kumar";
const age = 19;

function myTag(strings, personExp, ageExp) {
  const str0 = strings[0]; // "That "
  const str1 = strings[1]; // " is a "
  const str2 = strings[2]; // "."

  const ageStr = ageExp > 99 ? "centenarian" : "youngster";

  // We can even return a string built using a template literal
  return `${str0}${personExp}${str1}${ageStr}${str2}`;
}

const output = myTag`That ${person} is a ${age}.`;

console.log(output);
// That Kumar is a youngster.

Here, myTag is the tagged template that processes the strings, here "that", "is a", "." will be passed as an array of strings, then the expression ${person} is passed to personExp, and ${age} is passed to ageExp.

Escape sequences:

These are the characters, that you want to print, but they get skipped because they have special meanings attached to them.
Here is how to do a few formatting in strings in JavaScript.

\n - New line
\r - Carriage return, In Windows text files, a combination of two characters \r\n represents a new break, while on non-Windows OS it’s just \n. Most Windows software also understands \n.
\', \" - Quotes
\ - Backslash
\t - Tab
\b, \f, \v - Backspace, Form Feed, Vertical Tab

Example:

alert( 'I\'m the Kumar!' ); // I'm the Kumar!

String Length:

The length property has the string length:

alert( 'My\n'.length ); // 3

Note:

\n is a single “special” character, so the length is indeed 3
In the String, the length is just a property, it is not a function to be called upon strings.

Accessing characters

In JavaScript, To get a character at position pos, use square brackets [pos] or call the method str.at(pos). The first character starts from the zero position.

let str = `Hello`;
// the first character
alert( str[0] ); // H
alert( str.at(-1) ); // o

As usual, the last character is indexed at -1 and so on.

Properties and Important Methods:

1) Strings are immutable
Strings can’t be changed in JavaScript. It is impossible to change a character.
Examples:

let str = 'Hi';
str[0] = 'h'; // error

2) Changing the case
Methods toLowerCase() and toUpperCase() change the case:

alert( 'Kumar'.toUpperCase() ); // KUMAR
alert( 'Kumar'.toLowerCase() ); // kumar

3) Searching a substring:
It can be done using the .indexOf() function
let str = 'Widget with id';

alert( str.indexOf('Widget') ); // 0, because 'Widget' is found at the beginning
alert( str.indexOf('widget') ); // -1, not found, the search is case-sensitive

4) Getting a substring
There are 3 methods in JavaScript to get a substring: substring, substr and slice.

str.slice(start, end)
Returns the part of the string from start to (but not including) end.

If there is no second argument, then the slice goes till the end of the string:

let str = "stringify";
alert( str.slice(0, 5) ); // 'strin', the substring from 0 to 5 (not including 5)
alert( str.slice(2) ); // 'ringify', from the 2nd position till the end

str.substring(start, end)
Returns the part of the string between the start and end (not including the end).

This is almost the same as the slice, but it allows the start to be greater than the end (in this case it simply swaps start and end values).

let str = "stringify";
alert( str.substring(2, 6) ); // "ring"
alert( str.substring(6, 2) ); // "ring"

str.substr(start [, length])
Returns the part of the string from start, with the given length.

let str = "stringify";
alert( str.substr(2, 4) );

Comparing Strings:

Strings are compared character by character in alphabetical order. But there are a few odd things that would happen in the JavaScript world when you compare strings. Let's see a few of them here.

A lowercase letter is always greater than the uppercase:

alert( 'a' > 'Z' ); // true

Letters with diacritical marks are “out of order”:

alert( 'Österreich' > 'New zealand' ); // true
Here Ö has a diacritical mark. So it is greater than N, even though N comes before O in alphabetical order. This is because of the higher ASCII values of these special characters.

Here is one more way to compare strings
The call str.localeCompare(str2) returns an integer indicating whether str is less, equal or greater than str2 according to the language rules:

Returns a negative number if str is less than str2.
Returns a positive number if str is greater than str2.
Returns 0 if they are equivalent. For Example:

alert( 'Österreich'.localeCompare('Zealand') ); // -1

Unicode in JavaScript source code:

In JavaScript, the identifiers and string literals can be expressed in Unicode via a Unicode escape sequence. The general syntax is \uXXXX, where X denotes four hexadecimal digits. For example, the letter o is denoted as ‘\u006F’ in Unicode.

Example:

var f\u006F\u006F = 'abc';
console.log(foo) //abc

String Concatenation:
How can we end a string article on JavaScript without talking about the great concatenation?

Here is a brief overview of it. The concat() method joins two or more strings. This method does not change the existing strings. It returns a new string.
Syntax:
string.concat(string1, string2, ..., stringX)

Example:

let text1 = "Hello";
let text2 = "world!";
let result = text1.concat(" ", text2);
console.log(result)
//Hello world!

References:

Thank you for your valuable time!!! Happy Coding❤️

JavaScript Primitive vs Reference Values

Indira Kumar A K — Thu, 17 Nov 2022 09:40:45 +0000

Introduction:

JavaScript has mainly 2 types of values, namely

Primitive values (atomic values)
Reference values (objects which might consist of multiple kinds of values).

In this article, we will learn about

Memory in JavaScript
Types of Values in JavaScript
Properties of Primitive and Dynamic values
Copying property

Stack and Heap Memory:

Any variable in JS is stored in either heap or stack.

Static data:
It is the type of data whose size is known and so is fixed at compile time. It includes

Primitive values: null, undefined, Boolean, number, string, symbol, and BigInt
Reference values: Variables that are references and point to other objects

The above two have fixed sizes and so they are stored in the stack.

For example, the following declares two variables and initializes their values to a literal string and a number:

let name = 'John';
let age = 25;

Since the above two are primitive values, they will be stored in stack memory as shown below

Image credits:JavaScript Tutorial
Note: Many languages consider strings as an object, but JS considers strings as a primitive value

JavaScript stores objects, and functions in heap. The JS engine doesn't allocate fixed space for these, the memory is expanded as it is used.

Eg.

let name = 'John';
let age = 25;

let person = {
  name: 'John',
  age: 25,
};

Image credits:JavaScript Tutorial

Here, the 3 variables, name, age, and person(a reference that refers to the object in the heap) are stored in the stack. The actual values of objects are stored in a heap.

Dynamic properties:

A reference value can be used to add, change or delete properties at any time. However, this is not the same case for primitive values. In JS, syntactically primitive values are allowed to add properties, but they won't have any effects and are not saved.

Image credits:JavaScript Tutorial
Let us see the same example in the case of primitive values

Image credits:JavaScript Tutorial

How copying values work:

Primitive values:
In the case of primitive values, when copy statement is executed, the JS engine creates a copy of the value and assigns that value to the new variable.
Eg.

let age = 25;
let newAge = age;

Here,

First, age is initialized with the value 25.
Second, when the newAge variable is assigned with age, the JS engine creates a copy of the value of the age variable (creates a copy of value 25) and then assigns it to newAge.

Image credits:JavaScript Tutorial

So change in one place doesn't affect the change in another.

Reference Values:
When you assign a reference value from one variable to another, the JavaScript engine creates a reference so that both variables refer to the same object on the heap memory. This means that if you change one variable, it’ll affect the other.

let person = {
  name: 'John',
  age: 25,
};

let member = person;

member.age = 26;

console.log(person);
console.log(member);

Here both of them give the same output because the "member" reference value is pointing to the same object in the heap.

Image credits:JavaScript Tutorial

Summary:

Javascript has two types of values: primitive values and reference values.
You can add, change, or delete properties to a reference value, whereas you cannot do it with a primitive value.
Copying a primitive value from one variable to another creates a separate value copy. It means that changing the value in one variable does not affect the other.
Copying a reference from one variable to another creates a reference so that two variables refer to the same object. This means that changing the object via one variable reflects in another variable.

An Introduction to Operating System

Indira Kumar A K — Mon, 31 Oct 2022 03:56:52 +0000

Introduction

An Operating System is an interface between user and the hardware or between software and hardware. A Backend developer should be clear and crisp with the concepts of operating systems. OS has many purposes ranging from file management, memory management, process management, handling inputs and outputs etc. And that’s more or less the same thing a backend developer is expected to do, and so OS knowledge is indispensable.

The three most common operating systems for personal computers are

Microsoft Windows,
MacOS,
Android,
Linux.

Obviously for some people, reading different generations of OS is so boring, but still there exist few obsessed souls who want to know about that too, and here is an article for that

How Operation System work.

Computer CPU knows how to execute commands. But it needs someone to tell him what command to execute. It is the job of Operation System (OS). Whenever you power your computer, it reads first bytes on your Disk Drive, where it expects to see commands that will start Operation System.

Important functions of an operating System.

Memory Management
Processor Management
Device Management
File Management
Network Management
Security
Control over system performance
Job accounting
Error detecting aids
Coordination between other software and users

Memory Management:

Memory management refers to managing primary memory. Primary or Main memory is a large array of words (4 bytes), with each of them having their own address. And so, it can easily by accessed by the CPU.
Any program that is currently running resides in main memory, because since each word has its own address, OS takes the responsibility of storing which program is accessing what part. It takes care of the allocation and deallocation accordingly.

Process Scheduling:

This is the process of scheduling different processes for accessing processor. Here OS keeps tracks of processor and status of process. The program responsible for this task is known as traffic controller.

Device Management:

OS manages devices using drivers. OS keeps tracks of all devices and tracks which process uses what device for how much duration. Program responsible for this task is known as the I/O controller.

File Management:

A file in any computer in organized in form of directories, for easy navigation and access. An OS keeps of track of
The name of the file is divided into two parts as shown below:
• name
• extension, separated by a period.

Collection of files is a file directory. The directory contains information about the files, including attributes, location and ownership. Much of this information, especially that is concerned with storage, is managed by the operating system.

Apart from the above tasks, OS has few other operations too, A few of them are:

Security − By means of password and similar other techniques, it prevents unauthorized access to programs and data.
Error detecting aids − Production of dumps, traces, error messages, and other debugging and error detecting aids.
Job accounting − Keeping track of time and resources used by various jobs and users.

Resources:

Backend Development

Indira Kumar A K — Sat, 29 Oct 2022 04:17:04 +0000

Backend development is the process of writing code for anything behind the website or web app you are using. It is the server side of the website and a connector between the database and the frontend/User Interface.

A good backend developer should have the skills of designing, developing, scaling, and testing code that runs the business logic of the website.

Summary

Terminologies
Technologies and Tools
1. Server
2. Databases
3. Operating System
4. Software Stack
Additional Resources

Terminologies:

Let's see a few terminologies in Web Development before diving deep into the Backend.

Frontend / User Interface(UI) - This is the visual page that users see from their browsers and serves as an interface to the backend. The medium article that you are reading right now is a UI.

Backend - This is typically the server that sends/serves the content to your browser when you enter a website's URL.

Technologies and tools:

1) Server:

The server is typically a computer that listens to requests from a client or the front end. There are two types of servers namely,

a) Static server:
Here the webpages lie around as a file, when a request is made, the server sends it to the browser. Here a point to note is, Static server means that static files are saved in the server. In a single line, Every request from any browser will receive the same response i.e. the source code is the same.

A note to be made is, this has nothing to do with the dynamicity of the webpage itself, it can still have JavaScript and dynamically change contents according to the user events(refer DOM)

The best analogy to this is a Vending Machine.

b) Dynamic Server:
This kind of server is the one that modifies the content and renders a unique source code and serves it to the browser.
The best analogy to Dynamic Server is a Restaurant.

Here is a picture explaining the difference between dynamic and static server

Picture credit: Academind YouTube channel

What is better, Dynamic or Static?

Picture credit: Academind YouTube channel

Deployment of Different servers:

Picture credit: Academind YouTube channel

2) Databases:

Databases can be mainly categorized into two:
a) Relational Databases
b) Non Relational Databases

Picture Credit: Upwork

Things to learn from the database point of view:
· Schemas
· Normalization
· Stored procedure and triggers
· Knowledge of SQL commands
· Views

3) Operating Systems:

Knowledge of Operating Systems and different concepts related to them is indispensable to becoming a Backend Software Developer.

Here is an article explaining the main concepts of OS:
The 10 Operating System Concepts Software Developers Need to Remember

4) Software Stack:

Here you can find the top 10 frameworks for backend Dev:
10 Best Backend Frameworks for Web Development in 2022

Things to learn from the Backend point of view:
· Session management
· Authentication & Authorization
· Caching Mechanisms
· APIs & Web Services
· Software architectures (MVC)
· Software design patterns
· Algorithms and data structures
· Structured logging
· Debugging, profiling, and tracing
· Deployment
· Software testing
· Frameworks and Package Managers

Additional Resources:

How to dual-boot Ubuntu alongside Windows

Indira Kumar A K — Sat, 23 Apr 2022 10:55:05 +0000

Linux is a paradise for all the developer gods out there, and is something every beginner should be having hands-on. In this article we are going to see how to install Ubuntu alongside windows. This is suggested to most of the beginners because in case if something goes wrong, we can revert back to how the PC was before installation.

First download Latest version of Ubuntu from here
source: click here
Create a live USB using rufus
Burn the ISO file of ubuntu into an empty pen drive using rufus(you can refer to rufus official website if you have any doubt).
Now go to MyPc and right click -> manage -> disk management. Now create partitions according to your own convenience(you can use this article for reference).

I have created two disks with 25 GB SSD disk for root(so that booting is faster) and 200 GB HDD disk for file storage.
Go to start menu search bar and search "Change advanced startup options".

click Restart Now.

Now select Use a USB Drive.
Now it will reboot into the live USB
Click Install Ubuntu and from now select options according to your convenience.

Troubles that I faced:

When I installed ubuntu two years ago on dual boot mode, my pc was very slow.

How to Overcome:
The reason why it is slow is, the bootstrap of Ubuntu is saved in HDD part of the disk. So to overcome that, create a separate partition in SSD(you can use this article for reference) and use it for root folder of your Ubuntu OS.