updating README.md with new links

Author: rohan-paul

Git-and-Github/git-pull-most-important-and-regularly-used.md

@@ -0,0 +1,53 @@
+#### Pulling the latest update from a specific branch
+
+The **pull** command is used to download and integrate remote changes. The target (to which branch the data should be integrated into) is always the currently checked out HEAD branch.
+The source (from which branch the data should be downloaded from) can be specified in the command’s options.
+
+**Before using “git pull”, make sure the correct local branch is checked out. Then, to perform the pull, simply specify which remote branch you want to integrate. Assuming I am in ‘master’ branch in my local machine, and I want to incorporate changes from a remote repository’s ‘dev’ branch into the local machine’s branch.**
+
+```
+git checkout dev
+git pull origin dev
+```
+
+The branch-name option can be omitted, however, if a tracking relationship with a remote branch is set up. In most cases, however, your local branch will already have a proper tracking connection with a remote branch set up. This configuration provides default values so that the pull command already knows where to pull from without any additional options:
+
+```
+git pull
+```
+
+It’s often clearer to separate the two actions git pull does. The first thing it does is update the local tracking branch that corresponds to the remote branch. This can be done with git fetch.
+The second is that it then merges in changes, so in its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.
+
+More precisely, git pull runs git fetch with the given parameters and calls git merge to merge the retrieved branch heads into the current branch. With — rebase, it runs git rebase instead of git merge.
+
+
+#### How do I force “git pull” to overwrite local files?
+
+Important: If you have any local changes, they will be lost. With or without --hard option, any local commits that haven't been pushed will be lost
+
+git fetch --all
+
+Then, you have two options:
+
+``git reset --hard origin/master``
+
+OR If you are on some other branch:
+
+`git reset --hard origin/<branch_name>`
+
+git fetch downloads the latest from remote without trying to merge or rebase anything.
+
+Then the git reset resets the master branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/master.
+
+#### Another option is git stash
+
+Uncommitted changes, however (even staged), will be lost. Make sure to stash and commit anything you need.
+
+For that you can run the following:
+
+`git stash`
+
+And then to reapply these uncommitted changes:
+
+`git stash pop`

Promise-Async-Await-Sequential-Execution/Promise-async-await-master-notes/Promise-General-Notes.md renamed to Promise-Async-Await-Sequential-Execution/Promise-Super-Basic/Promise-General-Notes.md

@@ -0,0 +1,14 @@
+First note the first-principle constructor of a Promise - How to create and make a function that returns a Promise
+
+```js
+const createdPromise = new Promise((resolve, reject) => {
+  // do a thing, possibly async, then…
+
+  if (/* everything turned out fine */) {
+    resolve("Stuff worked!");
+  }
+  else {
+    reject(Error("It broke"));
+  }
+});
+```

Promise-Async-Await-Sequential-Execution/Promise-Super-Basic/Promise-super-basic-example-transorm-values-with-Promise.md

@@ -1,32 +1,32 @@
 // Both .then and .catch will return a new promise. That seems like a small detail but it’s important because it means that promises can be chained.
 
-let promise1 = new Promise((resolve, reject) => {
-  reject();
+let promise2 = new Promise((resolve, reject) => {
+  resolve();
 });
 
-promise1
+promise2
   .then(() => {
     console.log("Hey I am finished executing resolved()");
   })
   .catch(() => {
     console.log("Hey this time rejected, but will hit again");
   });
 
-// The above Will output - "Hey this time rejected, but will hit again"
+// The above Will output - Hey I am finished executing resolved()
 
-let promise2 = new Promise((resolve, reject) => {
-  resolve();
+let promise1 = new Promise((resolve, reject) => {
+  reject();
 });
 
-promise2
+promise1
   .then(() => {
     console.log("Hey I am finished executing resolved()");
   })
   .catch(() => {
     console.log("Hey this time rejected, but will hit again");
   });
 
-// The above Will output - Hey I am finished executing resolved()
+// The above Will output - "Hey this time rejected, but will hit again"
 
 let promise3 = new Promise((resolve, reject) => {
   reject();

Promise-Async-Await-Sequential-Execution/Promise-async-await-master-notes/promise-basic-implementation.js renamed to Promise-Async-Await-Sequential-Execution/Promise-Super-Basic/Promise-super-basic-implementation-GOOD-To-Start-with.js

@@ -0,0 +1,74 @@
+First note the first-principle constructor of a Promise - How to create and make a function that returns a Promise
+
+```js
+const createdPromise = new Promise((resolve, reject) => {
+  // do a thing, possibly async, then…
+
+  if (/* everything turned out fine */) {
+    resolve("Stuff worked!");
+  }
+  else {
+    reject(Error("It broke"));
+  }
+});
+```
+
+#### Now first Implementation - When Success case need to be returned
+
+```js
+const promise = new Promise((resolve, reject) => {
+  // do a thing, possibly async, then…
+
+  if (1 === 1) {
+    resolve("Stuff worked!");
+  } else {
+    reject(Error("It broke"));
+  }
+});
+```
+
+Will output the below
+
+```
+Stuff worked!
+
+```
+
+#### Now Second Implementation - When Error need to be returned
+
+```js
+const promise = new Promise((resolve, reject) => {
+  // do a thing, possibly async, then…
+
+  if (1 === 2) {
+    resolve("Stuff worked!");
+  } else {
+    reject(Error("It broke"));
+  }
+});
+
+promise.then(
+  result => {
+    console.log(result); // "Stuff worked!"
+  },
+  function(err) {
+    console.log(err); // Error: "It broke"
+  }
+);
+```
+
+The above will output the below
+
+```
+Error: It broke
+    at Promise (/home/rohan/codeLap/js/challenges/challenges-May-19/JS-Python_Challenges/test-code-1.js:19:12)
+    at new Promise (<anonymous>)
+    at Object.<anonymous> (/home/rohan/codeLap/js/challenges/challenges-May-19/JS-Python_Challenges/test-code-1.js:12:17)
+    at Module._compile (module.js:652:30)
+    at Object.Module._extensions..js (module.js:663:10)
+    at Module.load (module.js:565:32)
+    at tryModuleLoad (module.js:505:12)
+    at Function.Module._load (module.js:497:3)
+    at Function.Module.runMain (module.js:693:10)
+    at startup (bootstrap_node.js:188:16)
+```

Promise-Async-Await-Sequential-Execution/Promise-Super-Basic/absolute-super-basic-Promise-creation.md

@@ -2,34 +2,30 @@ const isMomHappy = true;
 
 // Define a function to return a Promise
 const willIGetNewPhone = new Promise((resolve, reject) => {
-	if (isMomHappy) {
-		const phone = {
-			brand: "Samsung",
-			color: "black"
-		};
-		resolve(phone);
-	} else {
-		const reason = new Error("Mon is not happy");
-		reject(reason);
-	}
+  if (isMomHappy) {
+    const phone = {
+      brand: "Samsung",
+      color: "black"
+    };
+    resolve(phone);
+  } else {
+    const reason = new Error("Mom is not happy");
+    reject(reason);
+  }
 });
 
 const showOff = phone => {
-	const message =
-		"Hey friend, I have a new " +
-		phone.color +
-		" " +
-		phone.brand +
-		" phone";
-	return Promise.resolve(message);
+  const message =
+    "Hey friend, I have a new " + phone.color + " " + phone.brand + " phone";
+  return Promise.resolve(message);
 };
 
 // call out promise
 const askMom = () => {
-	willIGetNewPhone
-		.then(showOff)
-		.then(fullfilled => console.log(fullfilled))
-		.then(error => console.log(error.message));
+  willIGetNewPhone
+    .then(showOff)
+    .then(fullfilled => console.log(fullfilled))
+    .then(error => console.log(error.message));
 };
 
 askMom();
@@ -40,50 +36,46 @@ askMom();
 
 // Promise
 const willIGetNewPhone = new Promise((resolve, reject) => {
-	if (isMomHappy) {
-		const phone = {
-			brand: "Samsung",
-			color: "black"
-		};
-		resolve(phone);
-	} else {
-		const reason = new Error("mom is not happy");
-		reject(reason);
-	}
+  if (isMomHappy) {
+    const phone = {
+      brand: "Samsung",
+      color: "black"
+    };
+    resolve(phone);
+  } else {
+    const reason = new Error("mom is not happy");
+    reject(reason);
+  }
 });
 
 // 2nd promise
 async function showOff(phone) {
-	return new Promise((resolve, reject) => {
-		var message =
-			"Hey friend, I have a new " +
-			phone.color +
-			" " +
-			phone.brand +
-			" phone";
+  return new Promise((resolve, reject) => {
+    var message =
+      "Hey friend, I have a new " + phone.color + " " + phone.brand + " phone";
 
-		resolve(message);
-	});
+    resolve(message);
+  });
 }
 
 // call our promise
 async function askMom() {
-	try {
-		console.log("before asking Mom");
+  try {
+    console.log("before asking Mom");
 
-		let phone = await willIGetNewPhone;
-		let message = await showOff(phone);
+    let phone = await willIGetNewPhone;
+    let message = await showOff(phone);
 
-		console.log(message);
-		console.log("after asking mom");
-	} catch (error) {
-		console.log(error.message);
-	}
+    console.log(message);
+    console.log("after asking mom");
+  } catch (error) {
+    console.log(error.message);
+  }
 }
 
 (async () => {
-	await askMom();
+  await askMom();
 })();
 
-/*Further Reading - 
+/*Further Reading -
 [https://scotch.io/tutorials/javascript-promises-for-dummies](https://scotch.io/tutorials/javascript-promises-for-dummies)*/