pure functions

Author: rohan-paul

Git-and-Github/alias-in-git-running-multiple-commands-with-alias.md

@@ -1,6 +1,6 @@
 ## Setting up alias in ~/.gitconfig file with which I can combine multiple commands in a single command - last implemented on 25-Jul-2018
 
-In $HOME/.gitconfig or .git/config include the below along with what ever was already existing in that file
+In \$HOME/.gitconfig or .git/config include the below along with what ever was already existing in that file
 
 ```
 [alias]
@@ -9,19 +9,17 @@ In $HOME/.gitconfig or .git/config include the below along with what ever was al
 
 ## And from now just do a push request with the following single command which will do all the above jobs set up in the above alias
 
-## $ git p "message ..."
-
+## \$ git p "message ..."
 
 ## How to alias 'git checkout' to 'git co'
 
 The command:
 
-``git config --global alias.co checkout``
-
+`git config --global alias.co checkout`
 
 will create a git alias to do that. It will add the following entry into your global ~/.gitconfig file:
 
 ```js
-[alias]
-    co = checkout
-```
+[alias];
+co = checkout;
+```

Javascript/Functional-Programming_Pure-Function/Pure-functions-functional-programming.md

@@ -0,0 +1,114 @@
+#### Basic example of mutations
+
+```js
+let state = {
+  wardens: 900,
+  animals: 800
+};
+```
+
+This above Object holds the information of a Zoo application. If we change the number of animals in the state Object:
+
+```js
+let state = {
+  wardens: 900,
+  animals: 800
+};
+state.animals = 90;
+```
+
+Our state object will hold/encode a new information:
+
+```js
+state = {
+  wardens: 900,
+  animals: 90
+};
+```
+
+This is called mutation.
+
+Immutability comes when we want to preserve our state. To keep our state from changing we have to create a new instance of our state objects.
+
+```js
+function bad(state) {
+  state.prp = "yes";
+  return state;
+}
+
+function good(state) {
+  let newState = { ...state };
+  newState.prp = "yes";
+  return newState;
+}
+```
+
+Immutability makes our app state predictable, ups the performance rate of our apps and to easily track changes in state.
+
+#### Pure Functions, Side Effects
+
+Pure functions are functions that accept an input and returns a value without modifying any data outside its scope(Side Effects). Its output or return value must depend on the input/arguments and pure functions must return a value.
+
+```js
+function impure(arg) {
+  finalR.s = 90;
+  return arg * finalR.s;
+}
+```
+
+The above function is not a pure function because it modified a state finalR.s outside its scope.
+
+```js
+function impure(arg) {
+  let f = finalR.s _ arg
+}
+```
+
+The above function also isn’t a pure function because it didn’t return a value though it didn’t modify any external state.
+
+```js
+function impure(arg) {
+  return finalR.s _ 3
+}
+```
+
+The above function is impure, though it didn’t affect any external state, its output return finalR.s \_ 3 isn't dependent on the input arg. Not only must pure function return a value but it must depend on the input.
+
+```js
+function pure(arg) {
+  return arg \_ 4
+}
+```
+
+The above is a pure function. It didn’t side effect any external state and it returns an output based on the input.
+
+#### 1. A pure function is deterministic. This means, that given the same input, the function will always return the same output. To illustrate this as a function in mathematical terms it is a well defined function. Every input returns a single output, every single time.
+
+A pure function
+
+`const add = (x, y) => x + y` // A pure function
+
+add is a pure function because it’s output is solely dependent on the arguments it receives. Therefore, given the same values, it will always produce the same output.
+
+#### 2. A pure function will not cause side effects. A side effect is any change in the system that is observable to the outside world.
+
+`const calculateBill = (sumOfCart, tax) => sumOfCart * tax`
+
+Is calculateBill pure? Definitely :) It exhibits the two necessary characteristics:
+
+The function depends only on its arguments to produce a result
+The function does not cause any side effects
+The Mostly Adequate Guide states that side effects include, but are not limited to:
+
+changing the file system
+inserting a record into a database
+making an http call
+mutations
+printing to the screen / logging
+obtaining user input
+querying the DOM
+accessing system state
+
+#### Further Reading
+
+[https://hackernoon.com/javascript-and-functional-programming-pt-3-pure-functions-d572bb52e21c](https://hackernoon.com/javascript-and-functional-programming-pt-3-pure-functions-d572bb52e21c)

Javascript/Functional-Programming_Pure-Function/functional-programming-pure-function-1.md

@@ -0,0 +1,5 @@
+Basic concepts are pure functions, side effects, data mutation and declarative over imperative.
+
+On top of that currying, compose and function composition are important concepts.
+
+Knowledge of libraries like RamdaJS provide useful utilities build applications in a more functional way. Functions being a first class citizen make it possible for JS to be really functional is important as well.

ONLY-Questions-Collections-Yet-to-draft-ans/whats-the-concept-of-functional-programming.md

@@ -1,4 +1,4 @@
-To put it simply, a higher-order component is a function, that takes a component and returns a new component. I like to think of them as parameterized components. Many times I find myself creating several components with very similar logic, with only 1 or 2 changes. Once I find a use case like this, it’s very simple to abstract the shared logic, and put the logic that changes into parameters.
+A higher-order component is a function, that takes a component and returns a new component. I like to think of them as parameterized components. Many times I find myself creating several components with very similar logic, with only 1 or 2 changes. Once I find a use case like this, it’s very simple to abstract the shared logic, and put the logic that changes into parameters.
 
 Since components are just functions and HOCs are just functions that return other functions, we can use functional concepts to chain them using utilities methods such as compose, which is provided by many libraries (it's included in Redux!).
 

React/HOC.md

@@ -0,0 +1,7 @@
+Design Strategy:
+
+To build high scaling application with ~zero downtime ~high availability one of our strategy would be to use Microservice based approach. Microservices is an approach to application development where a large application is built as a suite of granular services. Each service supports a specific business goal and uses a simple, well-defined interface to communicate with other services.
+
+#### Further Reading
+
+[http://blog.gainlo.co/index.php/2016/08/28/design-ecommerce-website-part-ii/](http://blog.gainlo.co/index.php/2016/08/28/design-ecommerce-website-part-ii/)